Python Rect.inflate_ip方法代码示例

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import inflate_ip [as 别名]
    def scrollbar_rect(self):
        # Get the distance between the scroll buttons (d)
        sub = self.scroll_up_rect().bottom
        t = self.scroll_down_rect().top
        d = t - sub
        # Get the total row number (n).
        n = self.num_items() / getattr(getattr(self, 'parent', None), 'num_cols', lambda: 1)()
        # Get the displayed row number (v)
        v = self.num_rows()
        if n:
            s = float(d) / n
        else:
            s = 0
        h = s * v
        if type(h) == float:
            if h - int(h) > 0:
                h += 1

        top = max(sub, sub + (s * self.scroll) + self.scroll_rel)
        r = Rect(0, top, self.scroll_button_size, h)
        m = self.margin
        r.right = self.width - m
        r.bottom = min(r.bottom, t)
        r.inflate_ip(-4, -4)
        if r.h < 1:
            r.h = int(h)
        return r

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import inflate_ip [as 别名]
 def scroll_down_rect(self):
     d = self.scroll_button_size
     r = Rect(0, 0, d, d)
     m = self.margin
     r.bottom = self.height - m
     r.right = self.width - m
     r.inflate_ip(-4, -4)
     return r

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import inflate_ip [as 别名]
 def scroll_up_rect(self):
     d = self.scroll_button_size
     r = Rect(0, 0, d, d)
     m = self.margin
     r.top = m
     r.right = self.width - m
     r.inflate_ip(-4, -4)
     return r

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import inflate_ip [as 别名]
 def scroll_left_rect(self):
     d = self.scroll_button_size
     r = Rect(0, 0, d, d)
     m = self.margin
     r.bottom = self.height - m
     r.left = m
     r.inflate_ip(-4, -4)
     return r

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import inflate_ip [as 别名]
class ThrowedGrenade(Bullet):
	def __init__(self,creator, x, y, speedX, speedY, throwDistance):
		Bullet.__init__(self, creator, x, y, speedX, speedY, "items-1small.png", None, Rect(110, 120, 9, 11))
		self.rect = Rect(x, y, 0, 0)
		self.speedX = speedX
		self.speedY = speedY

		# Important if you want pinpoint accuracy
		self.floatX = float(self.rect.x)
		self.floatY = float(self.rect.y)


		if throwDistance > MAX_THROW_DISTANCE:
			throwDistance = MAX_THROW_DISTANCE

		self.timeToStop = throwDistance / GRENADE_SPEED
		self.timeToBoom = TIME_TO_BOOM
		self.atk = 70

	def update(self, time, scene):
		self.floatX += self.speedX * time * GRENADE_SPEED
		self.floatY += self.speedY * time * GRENADE_SPEED
		self.rect.x = roundToInt(self.floatX)
		self.rect.y = roundToInt(self.floatY)

		self.timeToBoom -= time

		if self.timeToBoom <= 0:
			scene.bulletGroup.remove(self)
			scene.bulletGroup.add(Explosion(self.rect.x, self.rect.y))

			# Kill people!
			originalRect = self.rect.copy()
			self.rect.inflate_ip(80, 80)  # 80x80 area damage
			
			enemies_hit = sprite.spritecollide(self, scene.enemyGroup, False)

			for enemy in enemies_hit:
				# Friendly fire
				if self.creator.__class__.__name__ == enemy.__class__.__name__:
					continue
				enemy.receive_attack(self.atk)

			if sprite.collide_rect(self, scene.player):
				scene.player.receive_attack(self.atk)

			self.rect = originalRect  # Restore the real rect

		self.timeToStop -= time

		if self.timeToStop <= 0:
			self.speedX = 0
			self.speedY = 0

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import inflate_ip [as 别名]
 def test_inflate_ip__smaller( self ):
     "The inflate method inflates around the center of the rectangle"
     r = Rect( 2, 4, 6, 8 )
     r2 = Rect( r )
     r2.inflate_ip( -4, -6 )
     
     self.assertEqual( r.center, r2.center )        
     self.assertEqual( r.left+2, r2.left )
     self.assertEqual( r.top+3, r2.top )
     self.assertEqual( r.right-2, r2.right )
     self.assertEqual( r.bottom-3, r2.bottom )
     self.assertEqual( r.width-4, r2.width )
     self.assertEqual( r.height-6, r2.height )

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import inflate_ip [as 别名]
    def _DrawTextLines(self, lines):
        linepadding = 1
        textlines = []
        totalrect = Rect(0, 0, 0, 0)
        for line in lines:
            text = self.font.render(line, 1, (255, 255, 255))
            rect = text.get_rect()
            totalrect.inflate_ip(0, rect.height + linepadding)
            if rect.width > totalrect.width:
                totalrect.width = rect.width

            textlines.append(text)

        textsurf = Surface(totalrect.size, pygame.SRCALPHA)
        topoffset = 0
        for linesurf in textlines:
            textsurf.blit(linesurf, (0, topoffset))
            topoffset += linesurf.get_rect().height
        return textsurf

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import inflate_ip [as 别名]
    def hscrollbar_rect(self):
        # Get the distance between the scroll buttons (d)
        slr, slt = self.scroll_left_rect().topright
        d = self.scroll_right_rect().left - slr
        # The predefined step value
        _s = self.cell_size[1]
        # Get the total step number
        n = float(self.virtual_width) / _s
        # Get the visible step number
        v = float(self.width) / _s
        s = float(d) / n
        w = s * v
        if type(w) == float:
            if w - int(w) > 0:
                w += 1

        left = max(slr, slr + (d * (float(self.hscroll) / self.virtual_width)) + self.hscroll_rel)
        r = Rect(left, slt, w, self.scroll_button_size)
        r.right = min(r.right, d + slr)
        r.inflate_ip(-4, -4)
        return r

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import inflate_ip [as 别名]
 def get_bullet_rect(self, surf, lvl):
     r = Rect(0, 0, self.bullet_size, self.bullet_size)
     r.left = self.bullet_size * lvl
     r.inflate_ip(-4, -4)
     return r

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import inflate_ip [as 别名]
class Entity(Paintable, Updateable):
    entityBehaviors = Personality()
    attributes = Genotype()

    def __init__(self, world, family = None, position = None):
        if position == None:
            offsets = (int(dimension/5.0) for dimension in RESOLUTION)

            position = tuple(randint(offset, dimension - offset) 
                             for offset, dimension 
                             in zip(offsets, RESOLUTION))
    
        Paintable.__init__(self, position)
        self.boundingBox = Rect(position, self.attributes.dimensions)
        
        self.age = 0
        self.health = self.attributes.health
        self.growthFactor = self.attributes.growthFactor
        self.carriedEntity = None
        self.beingCarried = False

        if family:
            self.family = family
        else:
            self.family = Family(world)
            self.family.boundingBox = self.boundingBox
            
#        self.family.addMember(self)

#        self.behavior = ComplexBehavior(self, world)
        world.register(self)

    def getSpecies(self):
        return self.__class__.__name__
        
    def getFamily(self):
        return self.family
    
    def getDimensions(self):
        return [self.boundingBox.w, self.boundingBox.h]

    def getPosition(self):
        return self.boundingBox.center
    
    def getStride(self):
        return round(self.getDimensions()[0] / 2.)
        
    def isCarryingEntity(self, type = None):
        if type:
            return self.carriedEntity.__class__ == type
        else:
            return self.carriedEntity != None
    
    def paint(self, screen):
        draw.rect(screen, self.attributes.color, self.boundingBox)
        
    def update(self, delay, world):
        if self.__class__.entityBehaviors:
            for behavior in self.__class__.entityBehaviors:
                behavior.do(self, world)
                
        self.age += 1
        
    def grow(self, growthArea):
        growthFactor = self.growthFactor
        self.boundingBox.inflate_ip(growthArea[0] * growthFactor, growthArea[1] * growthFactor)
        gain = growthArea[0]  * growthArea[1]
#        print 'Gained %s health' % gain
        self.health += gain

    def carryEntity(self, entity):
        entity.beingCarried = True
        self.carriedEntity = entity
        
    def dropEntity(self):
        if self.carriedEntity:
            self.carriedEntity.beingCarried = False
            self.carriedEntity = None

    def hasBehavior(self, behavior):
        return self.behavior in behavior
    
    def addBehavior(self, behavior):
#        self.behavior.add(behavior)
        pass
    
    def removeBehavior(self, behavior):
#        self.behavior.removeBehavior(behavior)
        pass
    
    def __str__(self):
        return '%s (%s, %s)' % (self.__class__.__name__, self.boundingBox.x, self.boundingBox.y)

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import inflate_ip [as 别名]
 def get_margin_rect(self):
     r = Rect((0, 0), self.size)
     d = -2 * self.margin
     r.inflate_ip(d, d)
     return r