Python resource.get_image函数代码示例

 def __init__(self, xml_path, actual_value, max_value, x, y):
     
     parse = xml.dom.minidom.parse(data.get_path_xml(xml_path))
     
     bar = parse.getElementsByTagName('bar')
     
     image_code = str(bar[0].getAttribute('image_code'))
     self.bar_image = resource.get_image(image_code)
     self.bar_rect = self.bar_image.get_rect()
     self.bar_rect.x = x
     self.bar_rect.y = y
     
     controler = parse.getElementsByTagName('controler')
     
     image_code = str(controler[0].getAttribute('image_code'))
     self.controler_image = resource.get_image(image_code)
     self.controler_rect = self.controler_image.get_rect()
     self.controler_rect.centerx = self.bar_rect.centerx
     self.controler_rect.centery = self.bar_rect.centery
     
     font = parse.getElementsByTagName('font')
     
     font_code = str(font[0].getAttribute('font_code'))
     self.font = resource.get_font(font_code, 30)
     r = int(font[0].getAttribute('r'))
     g = int(font[0].getAttribute('g'))
     b = int(font[0].getAttribute('b'))
     self.color_font = (r,b,g)
     
     self.max_value = max_value
     self.actual_value = actual_value
     self.update_controler()
     self.still_pressed = False

 def __init__(self, text, x, y, normal_image_code, selected_image_code, font_code, center = False):
     
     self.normal_image = resource.get_image(normal_image_code)
     self.selected_image = resource.get_image(selected_image_code)
     self.rect = self.normal_image.get_rect()
     if center:
         self.rect.centerx = x
         self.rect.centery = y            
         self.centerx = x
         self.centery = y
     else:
         self.rect.x = x
         self.rect.y = y
         self.centerx = self.rect.w - seef.rect.x
         self.centery = self.rect.h - seef.rect.y
     
     self.mask = pygame.mask.from_surface(self.normal_image)
     self.list_rect = self.mask.get_bounding_rects()
     self.font = resource.get_font(font_code, 40)
     self.font2 = resource.get_font(font_code, 45)
     self.text = text
     self.selected = False
     self.change = True
     self.text_render_normal = self.font.render("Prueba", True, (248, 179, 51))
     self.text_render_selected = self.font2.render("Prueba", True, (188, 8, 37))

    def __init__(self, frame, content_view):
        # height = frame.size[1] + SCROLL_BUTTON_HEIGHT * 2
        # rect = pygame.Rect(frame.x, frame.y - SCROLL_BUTTON_HEIGHT, frame.w, height)
        rect = frame
        self.selected_index = None
        object_rectangle.ObjectRectangle.__init__(self, rect)

        self.content_frame = ScrollFrame(pygame.Rect(0, SCROLL_BUTTON_HEIGHT, frame.w, frame.h - SCROLL_BUTTON_HEIGHT * 2), content_view)
        self.content_view = content_view
        self._content_offset = (0, 0)

        # self.up_btn = button.Button(pygame.Rect(0, 0, rect.w, SCROLL_BUTTON_HEIGHT), u"△")
        # self.up_btn.border_widths = None
        self.up_image = resource.get_image("up")
        self.up_btn = imagebutton.ImageButton(pygame.Rect(0, 0, rect.w, SCROLL_BUTTON_HEIGHT), self.up_image, pygame.Rect(0, 0, SCROLL_BUTTON_HEIGHT * 2, SCROLL_BUTTON_HEIGHT * 2))
        self.up_btn.on_clicked.connect(self.up)
        # self.down_btn = button.Button(pygame.Rect(0, rect.h - SCROLL_BUTTON_HEIGHT, rect.w, SCROLL_BUTTON_HEIGHT), u"▽")
        # self.down_btn.border_widths = None
        self.down_image = resource.get_image("down")
        self.down_btn = imagebutton.ImageButton(pygame.Rect(0, rect.h - SCROLL_BUTTON_HEIGHT, rect.w, SCROLL_BUTTON_HEIGHT), self.down_image, pygame.Rect(0, 0, SCROLL_BUTTON_HEIGHT * 2, SCROLL_BUTTON_HEIGHT * 2))
        self.down_btn.on_clicked.connect(self.down)

        self.items = []
        self.items.append(self.up_btn)
        self.items.append(self.down_btn)
        self.items.append(self.content_frame)

        self._selected = False

    def __init__(self, xml_path):
        parser = xml.dom.minidom.parse(data.get_path_xml("cursor.xml"))

        root = parser.firstChild
        self.normal_image = resource.get_image(root.getAttribute("normal_image"))
        self.over_image = resource.get_image(root.getAttribute("over_image"))
        self.actual_image = self.normal_image

        self.x = self.y = 0
        self.update()

 def __init__(self, player, path_xml, is_ia = False):
     '''
     @brief Constructor.
     
     @param player Referencia al jugador.
     @param path_xml Ruta del archivo xml
     '''
     self.player = player
     parse = xml.dom.minidom.parse(data.get_path_xml(path_xml))
     
     #Obtenemos la imagen de fondo
     image = parse.getElementsByTagName('image')[0]
     image_code = image.getAttribute('image_code')
     self.image = resource.get_image(image_code)
     
     #Controla los misiles restantes
     self.missile = 0
     
     #Fuente para mostrar los misiles restantes
     self.font = resource.get_font('cheesebu', 40)
     
     #Posicion de la imagen de fondo
     self.centerx = int(image.getAttribute('centerx'))
     self.centery = int(image.getAttribute('centery'))
     self.position_image = self.image.get_rect()
     self.position_image.centerx = self.centerx
     self.position_image.centery = self.centery
             
     #Mapa para los items
     self.items = {}
     self.is_ia = is_ia
     
     #Recorremos cada uno de los items
     for element in parse.getElementsByTagName('item'):
         code = element.getAttribute('code')
         
         self.items[code] = {}
         self.items[code]['image'] = None
         self.items[code]['xml'] = None
         
         #Nos quedamos con su imagen de muestra
         image_code = element.getAttribute('image_code')
         self.items[code]['image'] = resource.get_image(image_code)
         
         #Y con su archivo xml de configuración
         path_xml = element.getAttribute('path_xml')
         self.items[code]['xml'] = path_xml
     
     if self.is_ia and 'turbo' in self.items.keys():
         del self.items['turbo']
     
     #En un principio no tenemos ningun item
     self.actual_item = None
     
     self.temp_angle = None

 def parser_car_info(self, parse):
     '''
     @brief Método que parsea la información básica de los coches.
     '''
     parent_node = parse.firstChild
     self.name_character = parent_node.getAttribute('name_character')
     self.avatar = resource.get_image(parent_node.getAttribute('avatar'))
     self.racer_image = resource.get_image(parent_node.getAttribute('racer_image'))
     self.max_speed = float(parent_node.getAttribute('max_speed'))
     self.original_max_speed = float(parent_node.getAttribute('max_speed'))
     self.min_speed = float(parent_node.getAttribute('min_speed'))
     self.rotation_angle = float(parent_node.getAttribute('rotation_angle'))
     self.aceleration = float(parent_node.getAttribute('aceleration'))
     self.desaceleration = float(parent_node.getAttribute('desaceleration'))

 def __init__(self, xml_path, actual_value, max_value, x, y, option = ''):
     '''
     @brief Constructor.
     
     @param xml_path Ruta del archivo xml.
     @param actual_value Valor actual que tendrá 
     @param max_value Valor máximo que puede alcanzar
     @param x Posición en el eje x
     @param y Posición en el eje y
     '''
     parse = xml.dom.minidom.parse(data.get_path_xml(xml_path))
     
     bar = parse.getElementsByTagName('bar')
     
     #Obtenemos la imagen que representará la barra
     image_code = str(bar[0].getAttribute('image_code'))
     self.bar_image = resource.get_image(image_code)
     
     #Indicamos su posicion
     self.bar_rect = self.bar_image.get_rect()
     self.bar_rect.x = x
     self.bar_rect.y = y
     
     #Obtenemos la imagen que representará al controlador
     controler = parse.getElementsByTagName('controler')
     image_code = str(controler[0].getAttribute('image_code'))
     self.controler_image = resource.get_image(image_code)
     
     #Indicamos su posición inicial
     self.controler_rect = self.controler_image.get_rect()
     self.controler_rect.centerx = self.bar_rect.centerx
     self.controler_rect.centery = self.bar_rect.centery
     
     #Cargamos la fuente con la que se representará el valor
     font = parse.getElementsByTagName('font')
     font_code = str(font[0].getAttribute('font_code'))
     self.font = resource.get_font(font_code, 30)
     r = int(font[0].getAttribute('r'))
     g = int(font[0].getAttribute('g'))
     b = int(font[0].getAttribute('b'))
     self.color_font = (r, b, g)
     
     self.max_value = max_value
     self.min_value = 0
     self.actual_value = actual_value
     self.update_controler()
     self.still_pressed = self.new_pressed = False
     self.option = option

 def __init__(self, father, xml_path):
     '''
     @brief Constructos.
     
     @param father Estado padre
     @param xml_path Ruta archivo xml con la configuración
     '''
     ClassificationMenu.__init__(self, father, xml_path)
     self.player = None
     self.total_time = None
     self.total_improved = None
     self.fast_lap = None
     self.lap_improved = None
     self.all_laps = None
     self.total_text = self.font.render('Tiempo total', True, (0, 0, 0))
     self.lap_text = self.font.render('Mejor Vuelta', True, (0, 0, 0))
     self.all_laps_text = self.font.render('Tiempos por vuelta', True, 
                                         (0, 0, 0))
     self.tiny_font = resource.get_font('cheesebu', 10)
     self.big_font = resource.get_font('cheesebu', 60)
     self.positions = {1: self.tiny_font.render('st', True, (189, 9, 38)), 
                     2: self.tiny_font.render('nd', True, (189, 9, 38)), 
                     3: self.tiny_font.render('rd', True, (189, 9, 38)),
                     4: self.tiny_font.render('th', True, (189, 9, 38))}
     
     self.record_image = resource.get_image('new_record')
     
     self.record_total_image = pygame.transform.rotozoom(self.record_image, 30, 1)
     self.record_lap_image = pygame.transform.rotozoom(self.record_image, 30, 0.7)

 def __init__(self):
     '''
     Carga e inicializa la configuración principal y las variables principales de la clase
     '''
     parser = xml.dom.minidom.parse(data.get_path_xml('configuration.xml'))
     
     for element in parser.getElementsByTagName('screen'):
         self.__screen_width = int(element.getAttribute('width'))
         self.__screen_height = int(element.getAttribute('height'))
         self.caption = element.getAttribute('caption')
     
     for element in parser.getElementsByTagName('fps'):
         self.fps = int(element.getAttribute('value'))
     
     pygame.init()
     self.screen = pygame.display.set_mode((self.__screen_width, self.__screen_height))
     
     for element in parser.getElementsByTagName('icon'):
         icon_code = str(element.getAttribute('code'))
         self.icon = resource.get_image(icon_code)
     
     pygame.display.set_icon(self.icon)
     self.clock = pygame.time.Clock()
     self.__actual_state = None
     
     ###########PRUEBA DE CIRCUIT###########
     
     self.circuit = circuit.Circuit(None, 'mapa1.tmx')

    def __init__(self, menu, xml_file, text, centerx, centery, font_code, image_code, image_x, image_y, show_text=True):
        """
        @brief Constructor
        
        @param xml_file Ruta del archivo xml con la configuración básica
        @param text Texto con la opción del botón
        @param centerx Posicion del centro de la x del botón
        @param centery Posicion del centro de la y del botón
        @param font_code Código de la fuente a usar
        @param image_code Código de la imagen a usar
        @param image_x Posición x de la imagen respecto al botón
        @param image_y Posición y de la imagen respecto al botón
        @param show_text Indica si se debe mostrar el texto o no
        """
        button.Button.__init__(self, menu, xml_file, text, centerx, centery, font_code, show_text)

        # Si se muestra el texto y no es sobre el botón, asignamos la posición
        if self.show_text:
            if not self.on_button:
                self.normal_text_rect.x += self.rect_draw.x
                self.normal_text_rect.y += self.rect_draw.y

        # Obtenemos la imagen del botón
        self.image = resource.get_image(image_code)

        # Obtenemos posición de la imagen
        self.rect_image = self.image.get_rect()
        self.rect_image.x = image_x + self.rect_draw.x
        self.rect_image.y = image_y + self.rect_draw.y

    def __init__(self, game_control, circuit, x, y, image_code, orientation, car_angle):
        """
        @brief Constructor.
        
        @param game_control Referencia a GameControl
        @param circuit Referencia a Circuit
        @param x Posición en el eje x
        @param y Posición en el eje y
        @param image_code Código de la imagen(será del mismo ancho y algo que 
        los tiles de circuito)
        @param orientation Indica si la linea será horizontal o vertical
        @param car_angle angulo para situar al coche
        """
        # Referencias
        self.game_control = game_control
        self.circuit = circuit

        # Posición
        self.x = x
        self.y = y

        # Imagen
        self.image = resource.get_image(image_code)

        self.orientation = orientation

        self.car_angle = car_angle

        if config.Config().get_mode() == config.TIMED:
            self.place_player()
        else:
            self.place_cars()

	def __init__(self, image, action = None, enable = None, **kwds):
		if isinstance(image, basestring):
			image = resource.get_image(image)
		if image:
			self.image = image
		BaseButton.__init__(self, action, enable)
		Widget.__init__(self, image.get_rect(), **kwds)

 def __init__(self):
     '''
     Carga e inicializa la configuración principal y las variables principales de la clase
     '''
     parser = xml.dom.minidom.parse(data.get_path_xml('configuration.xml'))
     
     for element in parser.getElementsByTagName('screen'):
         self.__screen_width = int(element.getAttribute('width'))
         self.__screen_height = int(element.getAttribute('height'))
         self.caption = element.getAttribute('caption')
     
     for element in parser.getElementsByTagName('fps'):
         self.fps = int(element.getAttribute('value'))
     
     pygame.init()
     self.screen = pygame.display.set_mode((self.__screen_width, self.__screen_height))
     
     for element in parser.getElementsByTagName('icon'):
         icon_code = str(element.getAttribute('code'))
         self.icon = resource.get_image(icon_code)
     
     pygame.display.set_icon(self.icon)
     self.clock = pygame.time.Clock()
     self.__actual_state = None
     
     ######PRUEBA MODULO PLAYER CAR##########
     
     self.car = playercar.PlayerCar("juego", 'coche_prueba.xml', 400, 300, 180)

 def __init__(self):
     '''
     Carga e inicializa la configuración principal y las variables principales de la clase
     '''
     os.environ["SDL_VIDEO_CENTERED"] = "1"
     
     parser = xml.dom.minidom.parse(data.get_path_xml('configuration.xml'))
     
     for element in parser.getElementsByTagName('screen'):
         self.__screen_width = int(element.getAttribute('width'))
         self.__screen_height = int(element.getAttribute('height'))
         self.caption = element.getAttribute('caption')
     
     for element in parser.getElementsByTagName('fps'):
         self.fps = int(element.getAttribute('value'))
     
     pygame.init()
     self.screen = pygame.display.set_mode((self.__screen_width, self.__screen_height))
     
     for element in parser.getElementsByTagName('icon'):
         icon_code = str(element.getAttribute('code'))
         self.icon = resource.get_image(icon_code)
         
     pygame.mouse.set_visible(False)
     pygame.display.set_icon(self.icon)
     
     self.clock = pygame.time.Clock()
     self.font = resource.get_font('cheesebu', 30)
     keyboard.update()
     
     ######PRUEBA MODULO GAME CONTROL##########
     self.__actual_state = gamecontrol.GameControl(self, 'circuits/circuit1-beach.tmx')

 def __init__(self):
     '''
     Carga e inicializa la configuración principal y las variables principales de la clase
     '''
     parser = xml.dom.minidom.parse(data.get_path_xml('configuration.xml'))
     
     for element in parser.getElementsByTagName('screen'):
         self.__screen_width = int(element.getAttribute('width'))
         self.__screen_height = int(element.getAttribute('height'))
         self.caption = element.getAttribute('caption')
     
     for element in parser.getElementsByTagName('fps'):
         self.fps = int(element.getAttribute('value'))
     
     pygame.init()
     self.screen = pygame.display.set_mode((self.__screen_width, self.__screen_height))
     
     for element in parser.getElementsByTagName('icon'):
         icon_code = str(element.getAttribute('code'))
         self.icon = resource.get_image(icon_code)
     
     pygame.mouse.set_visible(False)
     pygame.display.set_icon(self.icon)
     self.clock = pygame.time.Clock()
     self.__actual_state = mainmenu.MainMenu(self, 'menu/mainmenu.xml')