Python Surface.get_size方法代码示例

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import get_size [as 别名]
 def _get_raw_shadow(self):
     target_img = self.target.get_image(self.capture_state)
     r = target_img.get_rect()
     #the shadow will be larger in order to make free space for fadeout.
     r.inflate_ip(2*self.shadow_radius, 2*self.shadow_radius)
     img = Surface(r.size)
     img.fill((255, 255, 255, 255))
     img.blit(target_img, (self.shadow_radius, self.shadow_radius))
     if self.sun_angle <= 0.:
         raise Exception("Sun angle must be greater than zero.")
     elif self.sun_angle != 45. and self.vertical:
         w, h = img.get_size()
         new_h = h / tan(self.sun_angle * pi / 180.)
         screen_size = functions.get_screen().get_size()
         new_h = abs(int(min(new_h, max(screen_size))))
         img = scale(img, (w, new_h))
     if self.angle_mode == "flip":
         img = flip(img, self.mode_value[0], self.mode_value[1])
     elif self.angle_mode == "rotate":
         img = rotate(img, self.mode_value)
     else:
         raise Exception("angle_mode not available: " + str(self.angle_mode))
     shadow = pilgraphics.get_shadow(img,
                                     radius=self.shadow_radius,
                                     black=self.black,
                                     alpha_factor=self.alpha_factor,
                                     decay_mode=self.decay_mode,
                                     color=self.color)
     return shadow

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import get_size [as 别名]
    def main(self, screen):
        clock = pygame.time.Clock()
        background = Surface(screen.get_size())

        background.blit(construct_nightmare(background.get_size()), (0, 0))

        self.matris = Matris()
        matris_border = Surface((MATRIX_WIDTH * BLOCKSIZE + BORDERWIDTH * 2,
                                VISIBLE_MATRIX_HEIGHT * BLOCKSIZE + BORDERWIDTH * 2))
        matris_border.fill(BORDERCOLOR)

        while 1:
            dt = clock.tick(45)
            self.matris.update((dt / 1000.) if not self.matris.paused else 0)
            if self.matris.gameover:
                return

            tricky_centerx =  WIDTH - (WIDTH - (MATRIS_OFFSET + BLOCKSIZE *
                            MATRIX_WIDTH + BORDERWIDTH * 2)) / 2

            background.blit(matris_border, (MATRIS_OFFSET, MATRIS_OFFSET))
            background.blit(self.matris.surface, (MATRIS_OFFSET + BORDERWIDTH, 
                            MATRIS_OFFSET + BORDERWIDTH))

            nextts = self.next_tetromino_surf(self.matris.surface_of_next_tetromino)
            background.blit(nextts, nextts.get_rect(top = MATRIS_OFFSET, 
                                centerx = tricky_centerx))

            infos = self.info_surf()
            background.blit(infos, infos.get_rect(bottom = HEIGHT - MATRIS_OFFSET,
                                centerx = tricky_centerx))

            screen.blit(background, (0, 0))
            pygame.display.flip()

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import get_size [as 别名]
    def makebackground(self, surface):
        surface.fill((0,0,0))
        
        template = Surface(2*(min(self.zoom.width, self.zoom.height),))
        template.fill((0,0,0,255))
        width,height = template.get_size()

        ylim = surface.get_height()/height
        xlim = surface.get_width()/width

        data = self._data
        noise = [[pnoise2(self._selected[1][0]+x,
                          self._selected[0][0]+y,
                          4, 0.85) * 50
                  for x in range(xlim)]
                 for y in range(ylim)]

        hmin = hmax = 0
        for y in range(ylim):
            for x in range(xlim):
                yd = len(data)*float(y)/ylim
                xd = len(data[0])*float(x)/xlim

                h = self._height(data, yd, xd)
                n = noise[y][x]
                if h < 0:
                    h += -n if n > 0 else n
                else:
                    h += n if n > 0 else -n
                if h < hmin:
                    hmin = h
                if h > hmax:
                    hmax = h

        self.rects = []
        for y in range(ylim):
            for x in range(xlim):
                block = template.copy()
                yd = len(data)*float(y)/ylim
                xd = len(data[0])*float(x)/xlim

                h = self._height(data, yd, xd)
                n = noise[y][x]
                if h < 0:
                    h += -n if n > 0 else n
                else:
                    h += n if n > 0 else -n
                if h < 0:
                    color = 0, 0, int(255 * (1 - h/hmin))
                else:
                    color = 0, int(255 * h/hmax), 0
                block.fill(color)
                if self.selection:
                    if self.selection[0][0] <= yd <= self.selection[0][1]:
                        if self.selection[1][0] <= xd <= self.selection[1][1]:
                            block.fill((255,0,0,32),
                                       special_flags = BLEND_ADD)
                rect = Rect(x*width, y*height, width, height)
                surface.blit(block, rect.topleft)
                self.rects.append((rect, (yd, xd)))

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import get_size [as 别名]
    def next_tetromino_surf(self, tetromino_surf):
        area = Surface((BLOCKSIZE * 5, BLOCKSIZE * 5))
        area.fill(BORDERCOLOR)
        area.fill(BGCOLOR, Rect(BORDERWIDTH, BORDERWIDTH, 
                        BLOCKSIZE*5-BORDERWIDTH*2, BLOCKSIZE*5-BORDERWIDTH*2))

        areasize = area.get_size()[0]
        tetromino_surf_size = tetromino_surf.get_size()[0]

        center = areasize / 2 - tetromino_surf_size / 2 
        area.blit(tetromino_surf, (center, center))

        return area

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import get_size [as 别名]
    def blit_next_tetromino(self, tetromino_surf):
        """
        Draws the next tetromino in a box to the side of the board
        """
        area = Surface((BLOCKSIZE*5, BLOCKSIZE*5))
        area.fill(BORDERCOLOR)
        area.fill(BGCOLOR, Rect(BORDERWIDTH, BORDERWIDTH, BLOCKSIZE*5-BORDERWIDTH*2, BLOCKSIZE*5-BORDERWIDTH*2))

        areasize = area.get_size()[0]
        tetromino_surf_size = tetromino_surf.get_size()[0]
        # ^^ I'm assuming width and height are the same

        center = areasize/2 - tetromino_surf_size/2
        area.blit(tetromino_surf, (center, center))

        screen.blit(area, area.get_rect(top=MATRIS_OFFSET, centerx=TRICKY_CENTERX))

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import get_size [as 别名]
class Block(sprite.Sprite):
    """ Base Block Class """
    def __init__(self, pos, is_end):
        sprite.Sprite.__init__(self)
        self.pos = pos
        self.grid_pos = tuple([x/40 for x in self.pos])
        self.image = Surface((40, 40)).convert()
        self.color = (125, 125, 125)
        self.image.fill((255, 255, 255))
        self.rect = Rect(self.pos, self.image.get_size())
        self.is_shown = False
        self.is_path = False
        self.neighbors = set()
        self.path_value = 0
        self.is_end = is_end

    def get_neighbors(self, lst):
        for b in lst:
            if self in b:
                a = self

                # Left
                if b.index(a) != 0:
                    to_add = b[b.index(a)-1]
                    if to_add != self and not to_add.is_shown:
                        self.neighbors.add(b[b.index(a)-1])

                # Right
                if b.index(a) != len(b)-1:
                    to_add = b[b.index(a)+1]
                    if to_add != self and not to_add.is_shown:
                        self.neighbors.add(b[b.index(a)+1])

                # Above
                if lst.index(b) != 0:
                    to_add = lst[lst.index(b)-1][b.index(a)]
                    if to_add != self and not to_add.is_shown:
                        self.neighbors.add(lst[lst.index(b)-1][b.index(a)])

                # Below
                if lst.index(b) != len(lst)-1:
                    to_add = lst[lst.index(b)+1][b.index(a)]
                    if to_add != self and not to_add.is_shown:
                        self.neighbors.add(lst[lst.index(b)+1][b.index(a)])

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import get_size [as 别名]
class Island(WorldObject):
	def __init__(self, size, color, n = 20, ):
		super(Island, self).__init__()
		self.buffer = Surface(size)
		self.pointlist = []
		self.heights = []
		self.n = n
		self.color = color

	def redraw(self):
		self.pointlist = []
		self.heights = []
		if not self.pointlist:
			self.generate_terrain(self.buffer.get_size())

		if self.color:
			draw.polygon(self.buffer, white, self.pointlist)
		else:
			draw.polygon(self.buffer, black, self.pointlist)
		draw.lines(self.buffer, white, True, self.pointlist)
		#draw.lines(screen, [255, 0, 0], False, [(i, val) for i, val in enumerate(self.heights)])

	def generate_terrain(self, size):
		width, height = size
		scaling = 1.0 * width / self.n
		cumulative = [x * scaling for x in random_wander(self.n)]
		# turn heights into points
		self.pointlist = [(i * scaling, value + height - 300) for i, value in enumerate(cumulative) ]
		for x in range(width):
			i = floor(x / scaling)
			if i < 0:
				i = 0
			if i >= len(self.pointlist)-1:
				i = len(self.pointlist)-2
			remainder = x - i * scaling
			i = int(i)
			leftwidth, leftheight = self.pointlist[i]
			rightwidth, rightheight = self.pointlist[i + 1]
			h = leftheight + (rightheight - leftheight) * remainder / scaling
			self.heights.append(h)
		# add bottom right and bottom left
		self.pointlist.extend([size, (0, height)])

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import get_size [as 别名]
    def makebackground(self, surface):
        surface.fill((0,0,0))
        
        template = Surface(2*(min(self.zoom.width, self.zoom.height),),
                           flags=SRCALPHA)
        template.fill((0,0,0,255))
        width,height = template.get_size()

        o = min(surface.get_width()/width,
                surface.get_height()/height)/2

        self.rects = []
        for y in range(2*o):
            lat = asin(float(y-o)/o) * 180/pi
            r = int(sqrt(o**2-(o-y)**2))
            for x in range(o-r, o+r):
                block = template.copy()

                v = [float(x-r)/o, float(y-o)/o]

                if x >= o:
                    lon = self.rotate - acos(float((x-(o-r)-r))/r) * 180/pi
                else:
                    lon = self.rotate + 180 + acos(float(r-(x-(o-r)))/r) * 180/pi

                if lon > 180:
                    lon -= 360

                h = self.planet.sample(lat, lon)
                color = ((0,int(255 * (h/9000.0)),0) if h > 0
                         else (0,0,int(255 * (1 + h/11000.0))))

                block.fill(color)
                if self.selection:
                    if self.selection[0][0] <= lat <= self.selection[0][1]:
                        if self.selection[1][0] <= lon <= self.selection[1][1]:
                            block.fill((255,0,0,32),
                                       special_flags = BLEND_ADD)
                rect = Rect(x * width, y * height, width, height)
                surface.blit(block, rect.topleft)
                self.rects.append((rect, (lat, lon)))

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import get_size [as 别名]
class MovingPlayerView(TileView):

    folder_dict = {}
    ressource_dict = {}
    len_animation = 0

    def __init__(self, board_pos, board_id, direction, delay, callback=None):
        # Init view
        self.board_pos = XY(*board_pos)
        super(MovingPlayerView, self).__init__(self.board_pos, board_id)
        # Init attributes
        self.image = Surface((0,0))
        self.delay = delay
        self.dirty = 2
        # Get animation
        if direction in self.ressource_dict:
            self.counter = counter(self.len_animation)
            self.ressource = self.ressource_dict[direction]
        else:
            self.counter = counter(self.len_animation, reverse = True)
            self.ressource = self.ressource_dict[XY(*direction)*(-1,-1)]
        self.animation = (self.ressource[i] for i in self.counter)
        self.callback = callback

    def update(self):
        # Delay control
        if self.delay:
            self.delay -= 1
            return
        # Animation
        self.image = next(self.animation, None)
        if self.image is None:
            if callable(self.callback):
                self.callback()
            self.kill()
        else:
            self.rect.size = self.image.get_size()

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import get_size [as 别名]
    def makebackground(self, surface):
        surface.fill((0,0,0))
        
        template = Surface(2*(min(self.zoom.width, self.zoom.height),))
        template.fill((0,0,0,255))
        width,height = template.get_size()

        ylim = surface.get_height()/height
        dlat = float(self.selected[0][1] - self.selected[0][0])/ylim
        xmax = 0
        for y in range(ylim):
            lat = self.selected[0][0] + y * dlat
            scale = cos(lat * pi/180)

            w = int(surface.get_width() * scale/width)
            if w > xmax:
                xmax = w

        hmin = hmax = 0
        for y in range(ylim):
            lat = self.selected[0][0] + y * dlat
            scale = cos(lat * pi/180)

            xlim = int(surface.get_width() * scale/width)
            for x in range(xlim):
                dx = float(xmax - xlim)/2
                
                lon = self.selected[1][0] + (x + dx) * scale * dlat
                
                h = self.planet.sample(lat, lon)
                if h < hmin:
                    hmin = h
                if h > hmax:
                    hmax = h

        self.rects = []
        for y in range(ylim):
            lat = self.selected[0][0] + y * dlat
            scale = cos(lat * pi/180)

            xlim = int(surface.get_width() * scale/width)
            for x in range(xlim):
                dx = float(xmax - xlim)/2
                
                lon = self.selected[1][0] + (x + dx) * scale * dlat
                
                block = template.copy()
                h = self.planet.sample(lat, lon)
                if h < 0:
                    color = 0, 0, int(255 * (1 - h/hmin))
                else:
                    color = 0, int(255 * h/hmax), 0
                block.fill(color)
                if self.selection:
                    if self.selection[0][0] <= lat <= self.selection[0][1]:
                        if self.selection[1][0] <= lon <= self.selection[1][1]:
                            block.fill((255,0,0,32),
                                       special_flags = BLEND_ADD)
                rect = Rect(int(x+dx)*width, y*height, width, height)
                surface.blit(block, rect.topleft)
                self.rects.append((rect, (lat, lon)))

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import get_size [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 Surface [as 别名]
# 或者: from pygame.Surface import get_size [as 别名]
class HarmonyUi(object):
    image = None
    rect = None
    currPos = (0, 0) # current position of mouse
    selKey = 'None' # key of selected star system
    keys = ['A','A#','B','C',
            'C#','D','D#','E', # the key of the next
            'F','F#','G','G#'] # star created
    keyIndex = 0
    editKey = None
    editSpeed = 1 # Speed of next planet placed
    selStarId = 'None' # id of current selected star
    selPlanetId = 'None' # id of selected planet
    selNote = 'None' # note of current selecte planet
    selSpeed = 'None' # speed of current selected planet 
    labelSprites = None # unmutable labels for ui fields
    fieldSprites = None # mutable ui fields
    clearBg = None # background to clear sprites

    def __init__(self, screen, pos):
	self.image = Surface((screen.get_width(), 200))
        self.rect = self.image.get_rect()
        self.rect.topleft = (0, screen.get_height() - 200)
        self.currPos = pos
        self.editKey = self.keys[self.keyIndex]
        self.labelSprites = pygame.sprite.RenderUpdates()
        self.fieldSprites = pygame.sprite.RenderUpdates()
        self.clearBg = Surface(self.image.get_size())
        self.create_labels()
        self.create_fields()

    def set_selected_star(self, star):
        self.selKey = star.key
        self.selStarId = star.id

    def set_selected_planet(self, planet):
        self.selNote = planet.note
        self.selSpeed = planet.speed
        self.selPlanetId = planet.id
  
    def set_current_pos(self, pos):
	self.currPos = pos
    
    def get_edit_speed(self):
        return self.editSpeed

    def get_edit_key(self):
        return self.keyIndex

    # Create mutable fields and add them to 
    # the fieldSprites group. Since fields 
    # may change with each tick the group
    # is emptied and repopulated every call.
    def create_fields(self):
        self.set_current_pos(pygame.mouse.get_pos())
        self.fieldSprites.clear(self.image, self.clearBg)
        self.fieldSprites.empty()

        xpos = uiSprite(`self.currPos[0]`, (205,101), 'field', 'xpos')
        self.fieldSprites.add(xpos)
        ypos = uiSprite(`self.currPos[1]`, (205,126), 'field', 'ypos')
        self.fieldSprites.add(ypos)
        eSpeed = uiSprite(`self.editSpeed`, (80,100), 'field', 'eSpeed')
        self.fieldSprites.add(eSpeed)
        eKey = uiSprite(self.editKey, (80,125), 'field', 'eKey')
        self.fieldSprites.add(eKey)
        sid = uiSprite(self.selStarId, (353,101), 'field', 'sid')
        self.fieldSprites.add(sid)
        skey = uiSprite(self.selKey, (353,126), 'field', 'skey')
        self.fieldSprites.add(skey)
        pid = uiSprite(self.selPlanetId, (535,101), 'field', 'pid')
        self.fieldSprites.add(pid)
        pSpeed = uiSprite(self.selSpeed, (535,126), 'field', 'pSpeed')
        self.fieldSprites.add(pSpeed)

    # Create all of the labels for the ui fields
    # and place them in the labelSprites group
    def create_labels(self):
        xposLabel = uiSprite('xposlabel.png', (150, 100), 'label', 'xpl')
        self.labelSprites.add(xposLabel)
        yposLabel = uiSprite('yposlabel.png', (150, 125), 'label', 'ypl')
        self.labelSprites.add(yposLabel)
        speedLabel = uiSprite('speedlabel.png', (24, 100), 'label', 'spl')
        self.labelSprites.add(speedLabel)
        keyLabel = uiSprite('keylabel.png', (39, 125), 'label', 'kyl')
        self.labelSprites.add(keyLabel)
        staridLabel = uiSprite('staridlabel.png', (280, 100), 'label', 'sidl')
        self.labelSprites.add(staridLabel)
        starkeyLabel = uiSprite('starkeylabel.png', (275, 125), 'label', 'skl')
        self.labelSprites.add(starkeyLabel)
        pidLabel = uiSprite('planetidlabel.png', (448, 100), 'label', 'pidl')
        self.labelSprites.add(pidLabel)
        pspeedLabel = uiSprite('pslabel.png', (425, 125), 'label', 'psl')
        self.labelSprites.add(pspeedLabel)
 
    def draw_ui(self):
        self.labelSprites.draw(self.image)
        self.fieldSprites.draw(self.image)

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import get_size [as 别名]
# GET WEBCAM DATA BY PYGAME---------------
# Force SDL to write on our drawing area
os.putenv('SDL_WINDOWID', str(canvas.get_property('window').get_xid()))

# We need to flush the XLib event loop otherwise we can't
# access the XWindow which set_mode() requires
Gdk.flush()

pygame.init()
data = client_socket_test.recv(1024000)
image = Image.fromstring("RGB", (80, 60), data)
image = image.resize((640, 480))
image = pygame.image.frombuffer(image.tostring(), (640, 480), "RGB")

print Surface.get_size(image)
(WINX, WINY) = Surface.get_size(image)
# setting screen according to size
pygame.display.set_mode((WINX, WINY), 0, 0)
screen = pygame.display.get_surface()
#screen.blit(image, (0, 0))
#GLib.idle_add(pygame.display.update)
print "yoyo"

def updateImg(output):
    screen.blit(output, (0, 0))
    GLib.idle_add(pygame.display.update)
    print "boom"
    return True

videoListener = videoListenerThread(displayFunc=updateImg)

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

#.........这里部分代码省略.........
                pos = self.game.off([self.blit_pos[0] + self.rigging[1], self.blit_pos[1]])
                if self.game.Player.player_face == 'left':
                    #this prevents the "hover" look of the dagger off the default player body
                    pos[0] += 7
                width = self.directional_attack_image.get_rect().width
                d_rect = Rect([width - (self.range - self.attack_ticks), 0], [100, 100])
                self.weapon_rect = self.game.screen.blit(self.directional_attack_image, pos, d_rect)
                unoff_pos = self.game.unoff([self.weapon_rect.x, self.weapon_rect.y])
                self.weapon_rect.x = unoff_pos[0]
                self.weapon_rect.y = unoff_pos[1]

    def longAttack(self):
        self.attacking = True
        self.y_offset = 0
        self.x_offset = 0
        if self.game.Player.player_face == "front":
            self.init_angle = 180
        elif self.game.Player.player_face == "back":
            self.init_angle = 0
            self.y_offset = -self.game.Player.getSize()[1]*0.60 - self.attack_image.get_height()
            self.x_offset = -self.game.Player.getSize()[0]*0.60
        elif self.game.Player.player_face == "left":
            self.init_angle = 90
            self.x_offset = -self.game.Player.getSize()[0] - self.attack_image.get_height()
        elif self.game.Player.player_face == "right":
            self.init_angle = 270
        self.directional_attack_image = rotate(self.attack_image, self.init_angle)
        self.attack_rect = self.directional_attack_image.get_rect()
        self.angle = 0

    def longUpdate(self):
        if self.attacking:
            for x in xrange(5):
                attack_size = self.directional_attack_image.get_size()
                turn_point = [0, 0]
                if self.game.Player.isVertical():
                    turn_point = [attack_size[0]/2, 0]
                elif self.game.Player.isHorizontal():
                    turn_point = [0, attack_size[1]/2]
                self.mod_DAT = rotate(self.directional_attack_image, self.angle + 45)
                if self.angle < -90:
                    self.attacking = False
                self.angle -= 1

    def longBlit(self):
        if self.attacking:
            blit_pos = self.game.off(self.game.Player.getPos())
            blit_pos = vector.add(blit_pos, self.game.Player.getRigging())
            blit_pos = vector.sub(blit_pos, self.attack_image.get_size())

            #offset for left/back
            blit_pos[0] += self.x_offset
            blit_pos[1] += self.y_offset
            self.new_rect = self.game.screen.blit(self.mod_DAT, blit_pos)
            self.new_rect.center = self.attack_rect.center
            self.attack_rect = self.new_rect

    def rangedAttack(self):
        pass

    def rangedUpdate(self):
        pass

    def rangedBlit(self):
        pass

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import get_size [as 别名]
class Buffalo():
	def __init__(self, posX, posY, picture, size, resourcePath):
		self.picture = picture
		self.size = size
		self.resourcePath = resourcePath
		self.maxHealth = 100 * self.size
		self.health = self.maxHealth
		self.preimage = image.load(self.resourcePath + "img/" + self.picture + "_buffalo.png")
		self.image = scale(self.preimage, (int(self.preimage.get_width() * self.size),
										   int(self.preimage.get_height() * self.size)))
		self.healthFont = font.Font(None, 20)
		self.healthBarContainer = Surface((int(75 * self.size), int(12 * self.size))).convert()
		self.healthBarShader = Surface((self.healthBarContainer.get_width() + 6,
										self.healthBarContainer.get_height() + 6)).convert()
		self.healthNumber = self.healthFont.render(str(self.health), 1, (0, 0, 0))
		self.healthBarShader.fill((175, 175, 175))
		self.healthBar = Surface(self.healthBarContainer.get_size()).convert()
		self.healthColour = ()
		if (self.health >= 50):
			self.healthColour = (float((self.maxHealth - self.health) * 2 / self.maxHealth * 255), 255, 0)
		else:
			self.healthColour = (255, float(self.health * 2 / self.maxHealth * 255), 0)
		try:
			self.healthBar.fill(self.healthColour)
		except TypeError:
			self.healthBar.fill((0, 0, 0))
		self.healthBarContainer.blit(self.healthBar, (0, 0))
		self.value = 20 * self.size
		self.rect = Rect((0, 0), self.image.get_size())
		self.rect.x = posX
		self.rect.y = posY
		self.status = "alive"
		self.targetY = posY
		
	def update(self):
		self.preimage = image.load(self.resourcePath + "img/" + self.status + "_buffalo.png")
		self.image = scale(self.preimage, (int(self.preimage.get_width() * self.size),
										   int(self.preimage.get_height() * self.size)))
										   
		self.healthBarContainer = Surface((int(75 * self.size), int(12 * self.size))).convert()
		self.healthNumber = self.healthFont.render(str(int(self.health)), 1, (255, 255, 255))
		self.healthBarShader = Surface((self.healthBarContainer.get_width() + 6,
										self.healthBarContainer.get_height() + 6)).convert()
		self.healthBarShader.fill((175, 175, 175))
		if (self.health <= 0):
			self.healthBar = Surface((0, 0)).convert()
		else:
			self.healthBar = Surface((int(self.healthBarContainer.get_width() / self.maxHealth * self.health),
											self.healthBarContainer.get_height())).convert()
											
			if (self.health >= 50):
				self.healthColour = (float((self.maxHealth - self.health) * 2 / self.maxHealth * 255), 255, 0)
			else:
				self.healthColour = (255, float(self.health * 2 / self.maxHealth * 255), 0)
				
			try:
				self.healthBar.fill(self.healthColour)
			except TypeError:
				self.healthBar.fill((0, 0, 0))
			self.healthBarContainer.blit(self.healthBar, (0, 0))
		self.healthBarContainer.blit(self.healthNumber, (self.healthBarContainer.get_width() / 2 -
														 self.healthNumber.get_width() / 2,
														 self.healthBarContainer.get_height() / 2 -
														 self.healthNumber.get_height() / 2))
		self.healthBarShader.blit(self.healthBarContainer, (3, 3))
		
		if (self.status == "alive"):
			self.rect.x += float(3 - self.size)
			if (self.rect.y != self.targetY):
				if (self.rect.y < self.targetY):
					self.rect.y += float(3 - self.size)
				elif (self.rect.y > self.targetY):
					self.rect.y -= float(3 - self.size)
			return self.rect.center