Esempio n. 1
0
 def __init__(self, master, pos, img, states=["default"]):
     """
     Blits an image.
     """
     self.master = master
     self.master.add_widget(self)
     self.cursor = self.master.cursor
     self.id = id(self)
     self.pos = [pos[0]+self.master.rect.x, pos[1]+self.master.rect.y]
     self.img = img
     self.dimg = img
     self.rect = self.img.get_rect()
     self.rect.x = self.pos[0]
     self.rect.y = self.pos[1]
     self.states = states
     self.flashing = False
     if self.img.get_width()<=29:
         self.flashy = load_image("./data/image/menu/flashing_button1.png", \
         True).convert()
     else:
         self.flashy = load_image("./data/image/menu/flashing_button.png", \
         True).convert()
     self.alpha = 0
     self.flashy.set_alpha(0)
     self.frec = self.flashy.get_rect(center=self.rect.center)
     self.o = 1
Esempio n. 2
0
    def __init__(self, x, y):
        self.enemy_down = helpers.load_image('enemy_down.png', -1)
        self.enemy_up = helpers.load_image('enemy_down.png', -1)
        self.enemy_left = helpers.load_image('enemy_down.png', -1)
        self.enemy_right = helpers.load_image('enemy_down.png', -1)

        self.image = self.enemy_down
        if self.image == self.enemy_down:
            self.image1 = 1

        self.rect = self.image.get_rect(topleft=(x + 8, y + 8))

        self.health = 5

        self.name = 'silver'

        self.attack_area = 0
        self.attack_area_rect = 0

        self.damage = 15

        self.player_speed = options.player_speed
        self.speed = 3
        self.direction = random.randint(1, 4)
        self.move_type = 'random'
Esempio n. 3
0
def load_data():
    content_image = load_image('images/galata.jpg')
    content_image = rescale(content_image, 0.7, mode='reflect')
    style_image = load_image('images/starry-night.jpg')
    style_image = np.resize(style_image, (content_image.shape))
    data = [content_image, style_image]
    return data
Esempio n. 4
0
	def __init__(self, dataFolder, levelFile):
		self._dataFolder = dataFolder
		self._pelletCount = 0

		with open(levelFile) as f:
			self._level = simplejson.load(f)

		self._block, _ = helpers.load_image(self._get_image_name("block"))
		self._pellet, _ = helpers.load_image(self._get_image_name("pellet"))
		self._greenMan, _ = helpers.load_image(self._get_image_name("greenMan"))
		self._greenManClosed, _ = helpers.load_image(self._get_image_name("greenManClosed"))
		self._monster_01, _ = helpers.load_image(self._get_image_name("monster_01"))
		self._monster_scared_01, _ = helpers.load_image(self._get_image_name("monster_scared_01"))
		self._monster_evil_01, _ = helpers.load_image(self._get_image_name("monster_evil_01"))
		self._purpleMan, _ = helpers.load_image(self._get_image_name("purpleMan"))
		self._purpleManClosed, _ = helpers.load_image(self._get_image_name("purpleManClosed"))
		self._superPellet, _ = helpers.load_image(self._get_image_name("super_pellet"))
		self._images = {
			self.BLOCK: self._block,
			self.GREENMAN: self._greenMan,
			self.GREENMAN_CLOSED: self._greenManClosed,
			self.PELLET: self._pellet,
			self.MONSTER: self._monster_01,
			self.SCARED_MONSTER: self._monster_scared_01,
			self.EVIL_MONSTER: self._monster_evil_01,
			self.PURPLEMAN: self._purpleMan,
			self.PURPLEMAN_CLOSED: self._purpleManClosed,
			self.SUPER_PELLET: self._superPellet,
		}
		self._biteSound = pygame.mixer.Sound(self._get_sound_name("bite"))
		self._superSound = pygame.mixer.Sound(self._get_sound_name("super"))
		self._killSound = pygame.mixer.Sound(self._get_sound_name("kill"))
Esempio n. 5
0
 def load_sprites():
     base_dir = os.path.dirname(os.path.realpath(__file__))
     absolute_path = os.path.join(base_dir, 'sprites')
     sprites = os.listdir(absolute_path)
     for sprite in sprites:
         if sprite.endswith('png'):
             load_image('sprites/{}'.format(sprite))
Esempio n. 6
0
 def __init__(self, darkness):
     self.noflashlight = helpers.load_image('Noflashlight1.png', -1)
     self.noflashlightrect = self.noflashlight.get_rect(topleft=((-1),
                                                                 (-1)))
     self.flashlight = helpers.load_image('flashlight.png', -1)
     self.flashlightrect = self.flashlight.get_rect(topleft=((-1), (-1)))
     self.darkness = darkness
Esempio n. 7
0
    def __init__(self, x, y):
        self.tank_down = helpers.load_image('tank_down.png', -1)
        self.tank_up = helpers.load_image('tank_up.png', -1)
        self.tank_left = helpers.load_image('tank_left.png', -1)
        self.tank_right = helpers.load_image('tank_right.png', -1)

        self.image = self.tank_down

        self.rect = self.image.get_rect(topleft=(x + 8, y + 8))

        self.health = 100

        self.name = 'tank'

        self.attack_area = 0
        self.attack_area_rect = 0

        self.bullets = []

        self.damage = 100

        self.player_speed = options.player_speed
        self.speed = 3
        self.direction = random.randint(1, 4)
        self.move_type = 'random'

        x = file('data/options', 'rb')
        y = pickle.load(x)
        z = pickle.load(x)
        self.sounds = int(pickle.load(x))

        self.shoot1 = helpers.load_sound('hgun.wav')

        self.weapon = 1
    def __init__(self, win):
        self.win = win
        self.background = load_image(images.ENDING)
        self.selection_border = load_image(images.SELECTION_BORDER)
        self.replayarrow = load_image(images.REPLAYARROW)
        self.checkmark = load_image(images.CHECKMARK)

        self.selected_button_index = 0
Esempio n. 9
0
 def enableShield(self, player, powerupAmount):
     player.powerup = True
     player.damageFactor = powerupAmount
     image, rect = helpers.load_image('playerShielded.png', -1)
     player.image = image
     player.rect = rect
     time.sleep(10)
     image, rect = helpers.load_image('player.png', -1)
     player.image = image
     player.rect = rect
     player.powerup = False
Esempio n. 10
0
    def is_face_down(self, value):
        """is_face_down setter."""
        self._is_face_down = value

        if self._is_face_down:
            self.image = helpers.load_image('cards/back.png')
        else:
            self.image = helpers.load_image('cards/' + self.variant + '/' +
                                            self.id + '.png')

        self.rect = self.image.get_rect()
Esempio n. 11
0
    def _load_images(self):
        """Load all images."""
        logging.info('Loading images')

        self.images = {
            'area_cleared': helpers.load_image('area_cleared.png'),
            'area_uncleared': helpers.load_image('area_uncleared.png'),
            'mine_marker': helpers.load_image('mine_marker.png'),
            'mine_exploded': helpers.load_image('mine_exploded.png'),
            'mine': helpers.load_image('mine.png')
        }
Esempio n. 12
0
    def draw_battlefield(self):
        battlefield = load_image('images/battlefield-sand.png',
                                 scale=self.scale)

        left, top = self.left_top_coords_of_box(8.25, 2.5)
        self.displaySurface.blit(battlefield, (left, top))

        battlefield = load_image('images/battlefield-sand.png',
                                 scale=self.scale + 1)

        left, top = self.left_top_coords_of_box(0.5, 6)
        self.displaySurface.blit(battlefield, (left, top))
Esempio n. 13
0
    def _load_images(self):
        """Ustaw FishSprite.images, wczytując obrazki z dysku jeżeli to
        konieczne.
        """
        if hasattr(FishSprite, 'images'):
            return

        FishSprite.images = [
            load_image('fish/fish-1.gif'),
            load_image('fish/fish-2.gif'),
            load_image('fish/fish-3.gif'),
            load_image('fish/fish-4.gif')]
Esempio n. 14
0
    def __init__(self, x, y):
        self.x = x + 8
        self.y = y + 8

        self.player_down = helpers.load_image('player_down.png', -1)
        self.player_up = helpers.load_image('player_up.png', -1)
        self.player_right = helpers.load_image('player_right.png', -1)
        self.player_left = helpers.load_image('player_left.png', -1)

        self.image = self.player_down
        if self.image == self.player_down:
            self.image1 = 1
        else:
            self.image1 = 2
        self.rect = self.image.get_rect(topleft=(self.x, self.y))

        self.speed = options.player_speed

        self.health = 100

        self.weapons_slot = []
        self.pistol = weapons.Pistol(0, 0)
        self.pistol_rof = 60.00 / self.pistol.shoot_rate * options.fps
        self.can_shoot_pistol = 0

        self.rifle = weapons.Rifle(0, 0)
        self.rifle_rof = 60.00 / self.rifle.shoot_rate * options.fps
        self.can_shoot_rifle = 0

        self.machine_gun = weapons.MachineGun(0, 0)
        self.machine_gun_rof = 60.00 / self.machine_gun.shoot_rate * options.fps
        self.can_shoot_machine_gun = 0

        self.flame_thrower = weapons.FlameThrower(0, 0)
        self.flame_thrower_rof = 60.00 / self.flame_thrower.shoot_rate * options.fps
        self.can_shoot_flame_thrower = 0

        self.bullets = []

        self.blinking = 0

        self.recover_time = 15

        self.shoot1 = helpers.load_sound('hgun.wav')
        self.shoot2 = helpers.load_sound('hgun.wav')
        self.shoot3 = helpers.load_sound('mgun.wav')
        self.shoot4 = helpers.load_sound('rl1.wav')

        x = file('data/options', 'rb')
        y = pickle.load(x)
        z = pickle.load(x)
        self.sounds = int(pickle.load(x))
Esempio n. 15
0
def get_test_captions(debug=0):
    test_captions=list()
    ctr=0
    for filename in filenames_test:
        print('Analysing ',filename)
        if filename=='square_40.jpg':
            filename='square_4.jpg'
        image_path=path+filename
        image=load_image(image_path,size=img_size)
        image_batch=np.expand_dims(image,axis=0)
        transfer_values=image_model_transfer.predict(image_batch)
        captions_list=beam_search(transfer_values)
        image_captions=list()
        for caption in captions_list:
            s=sequence_to_sentence(caption['sequence'])
            conf=getAvgConfidence(caption)
            cap={'sentence':s,'score':conf}
            image_captions.append(cap)
        test_captions.append(copy.copy(image_captions))
        
        
        ctr+=1
        progress=100*ctr/len(filenames_test)
        print('processed ',ctr,'images\t%.2f%%'% progress)
        if debug:
            if ctr==3:
                return test_captions
    return test_captions
Esempio n. 16
0
    def __init__(self, image, height, speed, **kwargs):
        self.speed = speed
        if not isinstance(image, list):
            image = [image]

        self.image = [load_image(*i) for i in image]
        self.pos = [i.get_rect() for i in self.image]
Esempio n. 17
0
def run_inference(inf_file):
    # Preprocessing of the image happens here
    img = load_image(inf_file)
    print("Image Loaded")
    img = make_square(img)
    img = augment(prep, img)
    print("Transformations done")
    img = img.transpose(-1, 0, 1).astype(np.float32)
    img = img.reshape(-1, CHANNELS, IMG_WIDTH, IMG_HEIGHT)

    # Inferencing starts here
    sess = onnxruntime.InferenceSession("./best_acc.onnx")
    print("The model expects input shape: ", sess.get_inputs()[0].shape)
    print("The shape of the Image is: ", img.shape)
    input_name = sess.get_inputs()[0].name

    result = sess.run(None, {input_name: img})
    prob_array = result[0][0]
    print("Prob Array ", prob_array)
    prob = max(softmax(result[0][0]))
    print("Prob ", prob)
    species = tf.argmax(prob_array.ravel()[:10]).numpy()
    print("Class Label ", species)
    print("Spec ", CLASS_MAP[species][1])
    string_label = CLASS_MAP[species][1].split(" ")
    return (string_label[0], string_label[1], str(prob), color_code(prob))
Esempio n. 18
0
def main():
    image = helpers.load_image("test.png")
    pixels = image.load()
    width, height = image.size

    result = closest_color(pixels, width, height, palettes.sixteen)
    helpers.finish(result, "closest")
Esempio n. 19
0
def main():
    image = helpers.load_image("test.png")
    pixels = image.load()
    width, height = image.size

    result = gauss(pixels, width, height, g_kernel)
    helpers.finish(result)
Esempio n. 20
0
    def __init__(self):
        self.clock = pygame.time.Clock()
        self.window = pygame.display.set_mode(settings.WINDOW_SIZE,
                                              pygame.DOUBLEBUF)
        self.window_rect = self.window.get_rect()

        self.started_playing_at = None

        pygame.display.set_caption('Minesweeper')
        pygame.display.set_icon(helpers.load_image('icon.png'))

        self._load_fonts()
        self._load_images()
        self._load_sounds()

        stats_manager.load_stats(settings.STATS_FILE_NAME, self.stats)

        if os.path.isfile(settings.SAVE_FILE_NAME):
            save_game_manager.load_game(settings.SAVE_FILE_NAME, self,
                                        self.save_data)

            self.field.post_set_state(images=self.images, fonts=self.fonts)

            self.state = settings.GameState.PLAYING

            self._toggle_duration_counter(True)
        else:
            self._start_new_game()
 def __init__(self, xloc):
     pygame.sprite.Sprite.__init__(self)
     self.image, self.rect = helpers.load_image('pong_paddle.png')
     self.rect.centerx = xloc
     self.rect.centery = 400
     self.speed = 5
     self.yvel = 0
Esempio n. 22
0
class FastWalkEnemy(BaseEnemy):
    enemy = load_image('data/enemies/enemy.png', width, int(height * 1.2))

    def __init__(self, x, y, group):
        super().__init__(x, y, group)
        self.color = pygame.Color("yellow")
        self.width = width
        self.height = height * 1.2

        self.speed = choice([-fast, fast])
        self.range = range
        self.counter =  0

        self.image = FastWalkEnemy.enemy
        self.rect = pygame.Rect(x, y, self.width, self.height)

    def update(self, dt, platforms, hero_group, hero):
        self.gravitation()
        self.collide(0, self.vel_y, platforms, hero_group, hero)

        if abs(self.counter) >= self.range:
            self.speed = -self.speed

        self.rect = self.rect.move(self.speed, 0)
        self.collide(self.speed, 0, platforms, hero_group, hero)
        self.counter += self.speed
Esempio n. 23
0
 def __init__(self):
     pygame.sprite.Sprite.__init__(self)
     self.image, self.rect = load_image('snake.png', -1)
     self.pellets = 0
     self.speed = SPEED
     self.radius = 20
     self.boost = None
Esempio n. 24
0
    def draw_main_screen(self):
        self.displaySurface.fill(WHITE)

        background = load_image('images/background-mountain.png',
                                scale=self.scale)
        self.displaySurface.blit(background, (0, 0))

        self.draw_battlefield()

        left, top = self.left_top_coords_of_box(0.5, 0.5)
        outlinePosition = (left, top,
                           self.displaySurface.get_width() - int(self.boxsize),
                           self.displaySurface.get_height() -
                           int(self.boxsize))

        pygame.draw.rect(self.displaySurface, BLACK, outlinePosition,
                         self.linewidth)

        left, top = self.left_top_coords_of_box(0.5, 7)
        messagePosition = (left, top, self.boxsize * 9,
                           int(self.boxsize * 2.5))
        pygame.draw.rect(self.displaySurface, BLACK, messagePosition,
                         self.linewidth)

        left, top = self.left_top_coords_of_box(9, 7)
        commandPosition = (left, top, int(self.boxsize * 5.5),
                           int(self.boxsize * 2.5))
        pygame.draw.rect(self.displaySurface, BLACK, commandPosition,
                         self.linewidth)

        self.draw_pokemon()
        self.draw_pokemon_status()
        self.draw_menu()
        self.draw_exp_bar()
Esempio n. 25
0
def main():
    image = helpers.load_image("test.png")
    pixels = image.load()
    width, height = image.size

    result = sobel(pixels, width, height)
    helpers.finish(result)
Esempio n. 26
0
    def __init__(self, path, show_steps=False, save=False):
        self.image = Helpers.load_image(path)

        # build the prepocessing pipleine
        pipeline = Pipeline([
            Helpers.convert_to_grayscale, lambda image: Helpers.blur(image, 5),
            Helpers.thresholdify, Helpers.ellipse_morph
        ])

        processed_image = pipeline.process_pipeline(self.image)

        # get the contour, crop it out, find the corners and straighten
        contour = Helpers.largest_contour(processed_image)
        processed_image_cropped = Helpers.cut_out_rect(processed_image,
                                                       contour)
        corners = Helpers.get_corners(processed_image_cropped)

        # apply the same cropping and warping to the original image
        image_cropped = Helpers.cut_out_rect(self.image, contour)
        straigtened_image = Helpers.warp_perspective(corners, image_cropped)

        if show_steps:
            Helpers.show(processed_image, 'Preprocessing')
            Helpers.show(processed_image_cropped, 'Processed image cropped')
            Helpers.show(image_cropped, 'Original image cropped')
            Helpers.show(straigtened_image, 'Final image')

        self.final = straigtened_image

        if save:
            Helpers.save_image(
                f'{Helpers.IMAGE_DIRECTORY}/extractor_finish.png', self.final)

        return None
Esempio n. 27
0
    def __init__(self):
        self.clock = pygame.time.Clock()
        self.window = pygame.display.set_mode(settings.WINDOW_SIZE, pygame.DOUBLEBUF)
        self.window_rect = self.window.get_rect()

        pygame.display.set_caption('Tetris')
        pygame.display.set_icon(helpers.load_image('icon.png'))

        self.current_tetrimino = None
        self.next_tetrimino = None
        self.started_playing_at = None

        self._load_fonts()
        self._load_sounds()

        stats_manager.load_stats(settings.STATS_FILE_NAME, self.stats)

        if os.path.isfile(settings.SAVE_FILE_NAME):
            save_game_manager.load_game(settings.SAVE_FILE_NAME, self, self.save_data)

            self.is_fast_falling = False

            self._load_random_music()

            self._toggle_pause(True)
        else:
            self._start_new_game()
Esempio n. 28
0
 def __init__(self, position, possible_values):
     pygame.sprite.Sprite.__init__(self)
     self.image, self.rect = load_image('coin.png')
     self.rect.topleft = position
     
     #getting a value randomically
     key_value = random.randint(0, len(possible_values) - 1)
     self.value = possible_values.pop(key_value)
Esempio n. 29
0
 def __init__(self, powerupImage, powerupType, spawnLocation):
     pygame.sprite.Sprite.__init__(self)
     self.image, self.rect = helpers.load_image(powerupImage, -1)
     # Speed to move in pixels per update
     self.parentEntity = None
     self.powerupType = powerupType
     self.spawnLocation = spawnLocation
     self.currentLoc = spawnLocation
Esempio n. 30
0
    def load_sprites(self, scale):
        spriteList = [x[2] for x in os.walk('trainers/Red/')][0]

        self.sprites = {}

        for spriteFile in spriteList:
            image = load_image('trainers/Red/' + spriteFile, scale=scale)
            self.sprites[spriteFile.replace('.png', '')] = image
Esempio n. 31
0
 def __init__(self, image=None):
     super(Enemy, self).__init__()
     self.speed = random.randint(5, 20)
     if image == None:
         self.image, self.rect = load_image("Boximus.png", -1)
     else:
         self.image = image
         self.rect = image.get_rect(center=(520, random.randint(100, 575)))
Esempio n. 32
0
    def __init__(self, x, y):
        self.image = helpers.load_image('flashlight_picture.png', -1)
        self.rect = self.image.get_rect(topleft=(x + 9, y + 10))

        self.energy = 0
        self.recover_enery_rate = 10

        self.show = 1
Esempio n. 33
0
    def __init__(self, dificolty, w, h, pos=(2,2), direct=0):
        self.w = w
        self.h = h
        self.parts=[[pos, direct, 0]]

        self.direct = 0

        self.grow = 2
        self.pellets = 0
        self.sleep = 10-dificolty*1.5
        self.count = 200
        self.x, self.y = 0, 0

        self.head = helpers.load_image('snake_head.png', pink)
        self.tail = helpers.load_image('snake_tail.png', pink)
        self.strait = helpers.load_image('snake_strait.png', pink)
        self.turnS = helpers.load_image('snake_turn.png', pink)
Esempio n. 34
0
def main():
    # initializing pygame
    pygame.init()
    pygame.mixer.init()
    pygame.font.init()

    # setting up the game window
    resolution = config.get_resolution()
    win = pygame.display.set_mode(resolution)
    pygame.display.set_caption("Tudo que entra, também sai")
    pygame.display.set_icon(load_image(images.TOILET_ICON))
    clock = pygame.time.Clock()

    # scenes dictionary, to ease the access
    router = {
        START_SCENE: StartScene(win),
        GAME_SCENE: None,
        GAME_OVER_SCENE: GameOverScene(win),
        HOW_TO_PLAY_SCENE: HowToPlayScene(win),
        CREDITS_SCENE: CreditsScene(win)
    }

    # current scene being rendered
    current_scene = router[config.get(config.STARTING_SCENE) or START_SCENE]

    prev_command = None
    command = None

    while 1:
        events = pygame.event.get()
        for event in events:
            if event.type == pygame.QUIT:
                sys.exit()
            elif config.is_debug() and event.type == pygame.MOUSEBUTTONDOWN:
                print(pygame.mouse.get_pos())

        prev_command = command

        # renders a scene and receives a command from it
        if prev_command is not None:
            command = current_scene.render(
                events=events, more_args=prev_command.get('more_args'))
        else:
            command = current_scene.render(events=events)

        # when the previous command is not the game scene, it means we're starting a new game scene
        starting_at_game_scene = prev_command is None and command[
            'goto'] == GAME_SCENE
        moving_to_game_scene = prev_command is not None and prev_command[
            'goto'] != GAME_SCENE and command['goto'] == GAME_SCENE
        if starting_at_game_scene or moving_to_game_scene:
            router[GAME_SCENE] = GameScene(win)

        # the command contains a goto action indicating the next scene to be rendered
        current_scene = router[command['goto']]

        pygame.display.update()
        clock.tick(40)
Esempio n. 35
0
 def getSprites(self):
     block, rect = load_image('block.png')
     pellet, rect = load_image('pellet.png', -1)
     snake, rect = load_image('snake.png', -1)
     gwall, rect = load_image('gwall.png')
     ghost, rect = load_image('ghost.png', -1)
     ghost2, rect = load_image('ghost2.png', -1)
     ghost3, rect = load_image('ghost3.png', -1)
     ghost4, rect = load_image('ghost4.png', -1)
     return [pellet, block, snake, gwall, ghost, ghost2, ghost3, ghost4]
 def getLayout(self):
     return [[9, 9, 9 ,9, 9, 9, 9, 9],\
             [9, 9, 9, 9, 9, 9, 9, 9],\
             [9, 1, 1, 1, 1, 1, 1, 9],\
             [9, 0, 0, 0, 0, 0, 0, 9],\
             [9, 0, 1, 1, 0, 1, 1, 9],\
             [9, 0, 2, 0, 0, 0, 0, 9],\
             [9, 0, 1, 1, 0, 1, 0, 9],\
             [9, 0, 0, 0, 0, 1, 0, 9]
          
             
     
 def getSprites(self):
     block, rect = load_image('')
     pellet, rect = load_image('pellet.png',-1)
     snake, rect = load_image('snake.png',-1)
     return [pellet,block,snake]
     
Esempio n. 37
0
 def __init__(self):
     pygame.sprite.Sprite.__init__(self)
     self.image, self.rect = load_image("rocket.png")
     screen = pygame.display.get_surface()
     self.area = screen.get_rect()
     self.rect.topleft = 40, 310
     self.move = 9
     self.angle = -90
     self.dir = -5
     self.original = self.image
Esempio n. 38
0
 def __init__(self, position, possible_values):
     pygame.sprite.Sprite.__init__(self)
     
     #getting a value randomically
     key_value = random.randint(0, len(possible_values) - 1)
     fish = possible_values.pop(key_value)
     
     self.value = fish[0]
     self.image, self.rect = load_image(fish[1])
     self.rect.topleft = position
Esempio n. 39
0
 def __init__(self, pos, goal, creeps, pemit, player):
     pygame.sprite.Sprite.__init__(self)
     self.goal = goal
     self.creeps = creeps
     self.image = load_image("./data/image/objects/mchammer.png")
     self.rect = self.image.get_rect()
     self.rect.centerx = pos[0]
     self.rect.centery = pos[1]
     self.speed = 1
     self.particle_emitter = pemit
     self.player = player
Esempio n. 40
0
        def frames_in_direction(direction):
            frames = []

            for frame in range(1, self.number_of_frames+1):
                # Wczytaj klatkę z dysku.
                frame = load_image('penguin/penguin-%d-%s-%d.gif' % (id, direction, frame))
                # Nanieś na klatkę identyfikator gracza.
                add_name_to_penguin(str(self.penguin.number), frame, self.penguin.color)
                # Dodaj klatkę do listy.
                frames.append(frame)

            return frames
Esempio n. 41
0
    def __init__(self, image_names, path='../Images/Buttons', pos=(0, 0), function=None, parent=None,
                 text='Simple Button',
                 w=0, h=0):
        self.image_normal = helpers.load_image(image_names[0], alpha_channel=True,
                                               dir_name=path)  # изображение кнопки в базовом состоянии
        self.image_on_over = helpers.load_image(image_names[1], alpha_channel=True,
                                                dir_name=path)  # изображение кнопки в базовом состоянии
        self.image_on_click = helpers.load_image(image_names[2], alpha_channel=True,
                                                 dir_name=path)  # изображение кнопки в базовом состоянии
        self.images = [self.image_normal, self.image_on_over, self.image_on_click]  # список с кнопками
        if w != 0 and h != 0:  # изменение размера картинки, если заданы ширина и высота
            for i in range(0, 3):
                self.images[i] = pygame.transform.scale(self.images[i], (w, h))
        elif w != 0 and h == 0:  # если задан один размер, то второй изменяется пропорционально
            for i in range(0, 3):
                rect = self.images[i].get_rect()
                h = int(rect.h * (w / rect.w))
                self.images[i] = pygame.transform.scale(self.images[i], (w, h))
        elif w == 0 and h != 0:
            for i in range(0, 3):
                rect = self.images[i].get_rect()
                w = int(rect.w * (h / rect.h))
                self.images[i] = pygame.transform.scale(self.images[i], (w, h))

        self.current_image = self.images[0]  # текущая картинка

        self.rect = self.current_image.get_rect()
        self.rect.x = pos[0]
        self.rect.y = pos[1]

        self.text = Text_Button.Text(text)  # текст кнопки
        self.text_surf = self.text.font.render(text, True, (0, 0, 0))  # поверхность текста
        self.rect_text = self.text_surf.get_rect()  # рект текста
        # смещение текста на центр картинки кнопки,
        self.rect_text.x = self.rect.x + self.rect.w / 2 - self.rect_text.w / 2
        # к координате кнопки прибавляется половина длины картинки и отнимается половина длины текста
        self.rect_text.y = self.rect.y + self.rect.h / 2 - self.rect_text.h / 2

        self.function = function  # функция кнопки
        self.parent = parent  # родитель кнопки, по умолчанию отсутствует
Esempio n. 42
0
File: Snow.py Progetto: kotland/Snow
 def __init__(self, pos, wind_power=50):
     self.image = helpers.load_image('Bez_imeni.png', 1, IMAGE_PATH)
     self.pos = Vector(pos)
     self.speed = Vector((0, 5))
     self.transform()
     # self.angle = 6
     self.snow_list = []
     self.status = MOVE_DOWN
     wind1 = StrongWind(0.01, 0, 1, 0)
     wind2 = ConstantWind(-1*wind_power/1000, 0, random.randint(2000, 3000), 7000)
     self.winds = [wind1, wind2]
     w, h = 20, 20
     self.area = pygame.Rect(0, 0, w, h)
Esempio n. 43
0
  def __init__(self, pic):
    pygame.sprite.Sprite.__init__(self) 
    self.screen = pygame.display.get_surface()
    self.image, self.rect = helpers.load_image(pic, -1)
    new_size = random.randint(5, self.rect.width)
    self.image = pygame.transform.scale(self.image, (new_size, new_size))
    self.rect = self.image.get_rect()

    self.x = random.randint(0, self.screen.get_width())
    self.y = random.randint(0, self.screen.get_height()-self.rect.height)
    self.rect.topleft = (self.x, self.y)
    self.speedy = self.speedx = random.uniform(0.1, 0.3)
    self.curr_ticks = pygame.time.get_ticks()
Esempio n. 44
0
def setup():
    for i in xrange(20):
        continue
        #ROOT.children.append(RectNode(_random_color(), _random_rect()))

        sprite = pygame.sprite.DirtySprite(SpriteNode.spritegroup)
        sprite.image, sprite.rect = load_image("icon.png")
        node = SpriteNode(sprite)
        x, y = (random.randint(0, WIDTH), random.randint(0, HEIGHT))
        sprite.rect.center = x, y
        ROOT.children.append(node)

    for c in ROOT.children:
        print c.sprite.rect

    setup_ui()
    setup_pet()
Esempio n. 45
0
    def __init__(self, title="Penguin"):
        self.title = title

        # Inicjalizacja, ustawienie rozdzielczości i tytułu.
        pygame.init()
        self.screen = pygame.display.set_mode((self.width, self.height))
        pygame.display.set_caption(self.title)

        # Ustawienie powtarzania klawiszy.
        pygame.key.set_repeat(200, 30)

        # Wczytaj obrazek na górną belkę.
        self.status_bar_image = load_image('header.jpg')

        self.text = None

        # Zacznij odświeżać ekran z domyślną częstotliwością.
        refresh_it(self)
Esempio n. 46
0
 def __init__(self, player, coord_x, coord_y, rect=None):
     """Ctor"""
     pygame.sprite.Sprite.__init__(self)
     
     self.player = player
     self.coord_x = coord_x
     self.coord_y = coord_y
     
     if player == 1:
         img = 'one.png'
     elif player == 2:
         img = 'two.png'
     else:
         img = 'empty.png'
     
     self.image, self.rect = load_image(img, -1)
     
     if rect != None:
         self.rect = rect
 def __init__(self, pic):
   pygame.sprite.Sprite.__init__(self) 
   self.image, self.rect = helpers.load_image(pic, None)
   self.screen = pygame.display.get_surface()
   self.area = self.screen.get_rect()
   self.rect.topleft = (0, 0)
Esempio n. 48
0
 def __init__(self, location, layer = 2):
     pygame.sprite.DirtySprite.__init__(self)
     self._layer = layer
     
     self.image, self.rect = helpers.load_image('wall.png',-1)
     self.rect.center = location
Esempio n. 49
0
	def __init__(self, west=True):
		super().__init__()
		self.image, self.rect = load_image("airhorn2.png", -1)
		if west:
			self.image = pygame.transform.flip(self.image, True, False)
		self.rect.move_ip(800, 0)
Esempio n. 50
0
	def __init__(self):
		super().__init__()
		self.image, self.rect = load_image("derf.jpg", None)
		self.image = pygame.transform.scale(self.image, (int(500*0.80), int(707*0.80)))
		self.rect.move_ip(200, 0)
		self.cycles = 0
Esempio n. 51
0
 def __init__(self):
     pygame.sprite.DirtySprite.__init__(self)
     self.image, self.rect = helpers.load_image('mallet.png',-1)
     self.dirty = 2
     self._layer = 99
Esempio n. 52
0
    def _init_grounds(self):
        """Wczytaj obrazki podłoża, zbierając je w słowniku
        self.ground, gdzie klucz odpowiada znakowi użytemu
        na mapce poziomu.
        """
        self.ground = {
            ' ': load_image('ground/snow.gif'),
            '~': load_image('ground/water.gif'),
            '#': load_image('ground/wall.gif'),

            '[': load_image('ground/wall-horizontal-left.gif'),
            '=': load_image('ground/wall-horizontal-middle.gif'),
            ']': load_image('ground/wall-horizontal-right.gif'),

            '?': load_image('ground/wall-vertical-top.gif'),
            '|': load_image('ground/wall-vertical-middle.gif'),
            '.': load_image('ground/wall-vertical-bottom.gif'),

            '<': load_image('ground/ice-horizontal-left.gif'),
            '-': load_image('ground/ice-horizontal-middle.gif'),
            '>': load_image('ground/ice-horizontal-right.gif'),

            '^': load_image('ground/ice-vertical-top.gif'),
            '/': load_image('ground/ice-vertical-middle.gif'),
            ',': load_image('ground/ice-vertical-bottom.gif')}
Esempio n. 53
0
File: world.py Progetto: a-leut/sss
 def load_images(cls):
 	World.image = helpers.load_image('startile.png')
Esempio n. 54
0
 def getSprites(self):
     block, rect = load_image('blocos.png')
     pellet, rect = load_image('pellet.png',-1)
     snake, rect = load_image('livro.png',-1)
     letterA, rect = load_image('A.png',-1)
     letterB, rect = load_image('B.png',-1)
     letterC, rect = load_image('C.png',-1)
     letterCD, rect = load_image('CD.png',-1)
     letterD, rect = load_image('D.png',-1)
     letterE, rect = load_image('E.png',-1)
     letterF, rect = load_image('F.png',-1)
     letterG, rect = load_image('G.png',-1)
     letterH, rect = load_image('H.png',-1)
     letterI, rect = load_image('I.png',-1)
     letterJ, rect = load_image('J.png',-1)
     letterK, rect = load_image('K.png',-1)
     letterL, rect = load_image('L.png',-1)
     letterM, rect = load_image('M.png',-1)
     letterN, rect = load_image('N.png',-1)
     letterO, rect = load_image('O.png',-1)
     letterP, rect = load_image('P.png',-1)
     letterQ, rect = load_image('Q.png',-1)
     letterR, rect = load_image('R.png',-1)
     letterS, rect = load_image('S.png',-1)
     letterT, rect = load_image('T.png',-1)
     letterU, rect = load_image('U.png',-1)
     letterV, rect = load_image('V.png',-1)
     letterX, rect = load_image('X.png',-1)
     letterY, rect = load_image('Y.png',-1)
     letterW, rect = load_image('W.png',-1)
     letterZ, rect = load_image('Z.png',-1)
     letterAT, rect = load_image('AT.png',-1)
     
     return [pellet,block,snake,letterA,letterB,letterC,letterCD,letterD,letterE,letterF,letterG,letterH,letterI,letterJ,letterK,letterL,letterM,letterN,letterO,letterP,letterQ,letterR,letterS,letterT,letterU,letterV,letterX,letterY,letterW,letterZ,letterAT]
Esempio n. 55
0
 def getPicture(self):
     figura, rect = load_image('figuras/diamante.png',-1)
     picture = basicSprite.Sprite([640,300],figura,'IMG')
     return picture
 def getSprites(self):
     block, rect = load_image('')
Esempio n. 57
0
 def __init__(self, file_name, passable):
     pygame.sprite.Sprite.__init__(self)
     self.image, self.rect = helpers.load_image(file_name)
     self.passable = passable