Exemplo n.º 1
0
 def process_input(self, key, symbol, state: GameState, menu: Menu):
     if self.section == 'pause':
         if key == K_DOWN:
             self.__choice += 1
             Sounds().menu_selection.play()
             if self.__choice > 2:
                 self.__choice = 0
         elif key == K_UP:
             self.__choice -= 1
             Sounds().menu_selection.play()
             if self.__choice < 0:
                 self.__choice = 2
         elif key == K_RETURN:
             self.__select(menu)
         elif key == K_ESCAPE:
             self.__choice = 0
             self.is_active = False
             pygame.mixer.music.unpause()
     elif self.section == 'save':
         if key == K_RETURN:
             state.save(self.__savename)
             self.__savename = ''
             self.section = 'pause'
             self.is_active = False
             Sounds().menu_selection.play()
             pygame.mixer.music.unpause()
         elif key == K_BACKSPACE:
             self.__savename = self.__savename[:-1]
         else:
             self.__savename += symbol
Exemplo n.º 2
0
    def __init__(self):
        """Initialize the game, and create game resources"""
        pygame.init()

        self.settings = Settings()

        self.screen = pygame.display.set_mode(
            (self.settings.screen_width, self.settings.screen_height))
        pygame.display.set_caption("Alien Invasion")

        # self.screen = pygame.display.set_mode((0,0), pygame.FULLSCREEN)
        self.settings.screen_width = self.screen.get_rect().width
        self.settings.screen_hight = self.screen.get_rect().height

        # Create an instance to store game statistics,
        # and create a scoreboard.
        self.stats = GameStats(self)
        self.sb = Scoreboard(self)
        self.sounds = Sounds(self)

        self.ship = Ship(self)
        self.bullets = pygame.sprite.Group()
        self.aliens = pygame.sprite.Group()

        self._create_fleet()

        # Make the Play button.
        self.play_button = Button(self, "Play")
Exemplo n.º 3
0
    def attack(self, entity_lst):
        if self._inventory['equipment']['arm'] is not None:
            self._current_animation = 'attack'
            if self.__attack_count == 0:
                self._frame = 0
                self.__attack_count = 6
            elif self.__attack_count == 6:
                self.__attack_count = 12
            elif self.__attack_count == 12:
                self.__attack_count = FC_HERO_ATTACK

            for entity in entity_lst:
                if isinstance(entity, Monster):
                    if self.__side == RIGHT and self.position.x + 64 / TILE_SIZE[
                            0] <= entity.position.x <= self.position.x + 95 / TILE_SIZE[
                                0] and self.position.y - 13 <= entity.position.y <= self.position.y + 45 / TILE_SIZE[
                                    1]:
                        entity._health -= self._damage
                        if not entity.isDead():
                            Sounds().hit.play()
                    elif self.__side == LEFT and self.position.x - 61 / TILE_SIZE[
                            0] <= entity.position.x <= self.position.x - 32 / TILE_SIZE[
                                0] and self.position.y - 13 <= entity.position.y <= self.position.y + 45 / TILE_SIZE[
                                    1]:
                        entity._health -= self._damage
                        if not entity.isDead():
                            Sounds().hit.play()
Exemplo n.º 4
0
 def _check_play_button(self, mouse_pos):
     """Запускает новую игру при нажатии кнопки Play."""
     button_clicked = self.play_button.rect.collidepoint(mouse_pos)
     if button_clicked and not self.stats.game_active:
         # Сброс игровых настроек.
         self.settings.initialize_dynamic_settings()
         # Сброс игровой статистики.
         self.stats.reset_stats()
         self.stats.game_active = True
         # Обнуление статистики
         self.sb.prep_score()
         # Отображение текущего уровня
         self.sb.prep_level()
         # отображение оставшихся кораблей игрока
         self.sb.prep_ships()
         # Очистка списков пришельцев и снарядов.
         self.aliens.empty()
         self.bullets.empty()
         # Создание нового флота и размещение корабля в центре.
         self._create_fleet()
         self.ship.center_ship()
         # Указатель мыши скрывается.
         pygame.mouse.set_visible(False)
         # Запускаем музыку сражения
         fighting_music = Sounds('sounds/fighting.mp3')
         fighting_music.playing_music()
Exemplo n.º 5
0
    def __init__(self, modes):
        GPIO.setmode(
            GPIO.BCM)  #set up to use gpio port numbers (instead of pin #s)

        self.buttons = Buttons()
        self.optos = Optos()
        self.lights = Lights()
        self.outlets = Outlets()
        self.sounds = Sounds()
        self.clock = Countdown(12)

        self.modes = modes
        self.last_time = time.localtime()
Exemplo n.º 6
0
 def tutorial_msg(step=0):
     if step == 0:
         return "You've finished our small tutorial. What would you like to do now? Do the grammar or the pronunciation exercise?"
     elif step == 1:
         return 'Welcome to the grammar exercise. I will give you an infinitive and the tense in which it should be used. \
         The ' + Sounds.beep() + ' beep sound shows you where the correct verbform should go. \
         I will do the first one: <break time="1s" /> To go <break time="1s"/> \
         simple past <break time="1s"/> I ' + Sounds.beep() + ' to the park. \
         <break time="1s"/> The correct answer would be <break time="1s"/> I walked in the park. <break time="1s"/>  Now it is your turn! '
     elif step == 2:
         return '<break time="1s"/> Now let\'s move on to the pronunciation exercise<break time="1s"/>'
     else:
         return ''
Exemplo n.º 7
0
def apply(state):
    editor = SoundEditor(state)
    for cur in editor:
        next = cur.next
        if next.value is None:
            continue

        x, y = cur.value, next.value
        if x in Sounds('ac'):
            cur.value, next.value = ac_sandhi(x, y)
        elif x in Sounds('hal'):
            cur.value, next.value = hal_sandhi(x, y)

    yield editor.join()
Exemplo n.º 8
0
def start_game():

    #needs to be called before pygame.init
    pygame.mixer.pre_init(22050, -16, 2, 1024)

    window = Window()
    window.init()

    pygame.init()

    sounds = Sounds()
    sounds.init()
    window.sounds = sounds
    pygame.mixer.set_num_channels(32)

    # meta game loop
    while True:
        sounds.play_music("intro", loop=1)
        intro_main(window, handle_events)

        # so we can mix more channels at once.  pygame defaults to 8.
        #sounds.play("jump1")
        #sounds.play("hit1")
        #sounds.play("goal1")
        sounds.set_music_tracks(['track-one', 'track-two'])

        world = World()
        world.stage = 2
        populate(world, window)

        def count_leaves():
            no_leaves = 0
            for item in world.items:
                if item.role == "Bough":
                    no_leaves = no_leaves + 1
            return no_leaves

        CleanUp_Event = pygame.event.Event(CLEANUP,
                                           message="Cleaning Up Your shit")
        pygame.time.set_timer(CLEANUP, 1000)

        TickTock = pygame.event.Event(
            TICK_TOCK, message="TickTock goes the Ticking Clock")
        pygame.time.set_timer(TICK_TOCK, int(90000 / count_leaves()))

        AddCherry = pygame.event.Event(ADDCHERRY, message="Ooooo Cherry")
        pygame.time.set_timer(ADDCHERRY, int(90000 / 5))

        AddOwange = pygame.event.Event(ADDOWANGE, message="Ooooo owange")
        pygame.time.set_timer(ADDOWANGE, int(1000 * 5))

        for i in range(3):
            event.post(AddOwange)

        pygame.time.set_timer(BIRDY, 1000 * 7)

        render = Render(window, world)
        quit = runloop(window, world, render)
        if quit:
            return
Exemplo n.º 9
0
 def __init__(self, screen, user, maze):
     self.screen = screen
     self.maze = maze
     self.user = user
     self.sounds = Sounds(
         sound_files=['portal-open.wav', 'portal-travel.wav'],
         keys=['open', 'travel'],
         channel=PortalController.PORTAL_AUDIO_CHANNEL)
     self.blue_portal = pygame.sprite.GroupSingle(
     )  # portals as GroupSingle, which only allows one per group
     self.blue_projectile = None
     self.orange_portal = pygame.sprite.GroupSingle()
     self.orange_projectile = None
     self.portal_directions = {'l': 'r', 'r': 'l', 'u': 'd', 'd': 'u'}
Exemplo n.º 10
0
def al_tasya(target, result):
    target = Sounds(target)
    result = Sounds(result)

    def func(value):
        letters = list(value)
        for i, L in enumerate(letters):
            if L in target:
                letters[i] = Sound(L).closest(result)
                # 1.1.51 ur aṇ raparaḥ
                if L in 'fF' and letters[i] in Sounds('aR'):
                    letters[i] += 'r'
                break
        return ''.join(letters)
    return func
Exemplo n.º 11
0
def hal_sandhi(x, y):
    """Apply the rules of hal sandhi to `x` as followed by `y`.

    These rules are from 6.1. A rule is part of hal sandhi iff the first
    letter is a consonant.

    :param x: the first letter.
    :param y: the second letter.
    """

    # 6.1.66 lopo vyor vali
    if x in Sounds('v y') and y in Sounds('val'):
        x = ''

    return x, y
Exemplo n.º 12
0
def run_game():
    # Initialize pygame, settings, and screen object.
    pygame.mixer.pre_init(44100, -16, 2, 2048)
    pygame.mixer.init()
    pygame.init()
    game_settings = GameSettings()
    screen = pygame.display.set_mode((game_settings.screen_width, game_settings.screen_height))
    pygame.display.set_caption("Pac Man Portal")

    # Open sprite sheet
    sprite_sheet = SpriteSheet(file_name='images/spritesheet.png')

    # Make the Play and Scores button.
    play_button = Button(screen=screen, msg="Play", order=0)
    score_button = Button(screen=screen, msg="High Scores", order=1)

    # Open high score file
    try:
        high_score_file = open("high_score_file.txt", "r+")
    except FileNotFoundError:
        high_score_file = open("high_score_file.txt", "w+")

    # Open maze layout file
    maze_file = open('mazelayout.txt', 'r')

    # Make sound manager
    sounds = Sounds()

    # Initialize game stats and scoreboard
    stats = GameStats(game_settings=game_settings)
    sb = Scoreboard(screen=screen, game_settings=game_settings, stats=stats, sprite_sheet=sprite_sheet,
                    high_score_file=high_score_file, sounds=sounds)

    # Initialize pacman
    pacman = Pacman(screen=screen, game_settings=game_settings, stats=stats, sb=sb,
                    image_list=sprite_sheet.pacman_image, death_anim_list=sprite_sheet.pacman_death_image,
                    sounds=sounds)

    # Initialize maze
    maze = Maze(screen=screen, game_settings=game_settings, maze_file=maze_file, sprite_sheet=sprite_sheet,
                pacman=pacman, sounds=sounds)

    # Initialize the event handler
    event_handler = EventHandler(pacman=pacman, play_button=play_button, score_button=score_button, stats=stats, sb=sb,
                                 maze=maze, sounds=sounds)

    # Initialize the display manager
    display = Display(screen=screen, game_settings=game_settings, stats=stats, sb=sb, sprite_sheet=sprite_sheet,
                      play_button=play_button, score_button=score_button, maze=maze, pacman=pacman,
                      event_handler=event_handler, sounds=sounds)

    # Start the main loop for the game
    while True:
        event_handler.check_events()
        if stats.game_active:
            pacman.update(maze=maze, display=display)
            maze.update_ghosts()
            maze.update_bullets()
            maze.update_portals()
        display.update_screen()
Exemplo n.º 13
0
    def __init__(self):
        """ iniciando el juego y recursos"""
        pygame.init()
        self.settings = Settings()

        self.screen = pygame.display.set_mode(
            (self.settings.screen_width, self.settings.screen_height))
        pygame.display.set_caption("Alien Invasion by David")

        self.bg_x = self.settings.bg_x_pos

        self.ship = Ship(self)
        self.bullets = pygame.sprite.Group()

        self.sounds = Sounds()

        self.alien = Alien(self)
        self.aliens = pygame.sprite.Group()
        self._create_fleet()

        # crea el boton
        self.play_button = Button(self, 'Jugar')

        # crea una instancia de game stats
        self.stats = GameStats(self)
        # crea una insancia de Score
        self.sb = Scoreboard(self)
Exemplo n.º 14
0
    def __init__(self):
        pygame.init()
        pygame.display.set_caption("Pacman Portal")
        self.screen = pygame.display.set_mode((800, 600))
        self.maze = Maze(screen=self.screen, maze_map_file='pacmanportalmaze.txt')
        self.clock = pygame.time.Clock()
        self.ghost_sounds = Sounds(sound_files=['ghost-blue.wav', 'ghost-eaten.wav', 'ghost-std.wav'],
                                                keys=['blue', 'eaten', 'std'],
                                                channel=Ghost.audio)

        self.stock = PacmanLives(screen=self.screen, ct_pos=((self.screen.get_width() // 3),
                                                                      (self.screen.get_height() * 0.965)),
                                          images_size=(self.maze.block_size, self.maze.block_size))
        self.score = ScoreController(screen=self.screen,
                                            sb_pos=((self.screen.get_width() // 5),
                                                    (self.screen.get_height() * 0.965)),
                                            items_image='cherry.png',
                                            itc_pos=(int(self.screen.get_width() * 0.6),
                                                     self.screen.get_height() * 0.965))
        self.next_level = NextLevel(screen=self.screen, score_controller=self.score)
        self.game_over = True
        self.pause = False
        self.player = Pacman(screen=self.screen, maze=self.maze)
        self.ghosts = Group()
        self.ghost_time = 2500
        self.ghosts_stack = None
        self.top_ghost = None
        self.arr_ghost = []
        self.spawn_ghosts()
        self.events = {PacmanPortal.START_EVENT: self.init_ghosts, PacmanPortal.REBUILD_EVENT: self.rebuild_maze, PacmanPortal.LEVEL_EVENT: self.clear_level}
Exemplo n.º 15
0
    def func(state, index, locus):
        term = state[index]
        term_value = term.get_at(locus)
        new_value = None
        add_part = False

        # 1.1.54 ādeḥ parasya
        if adi:
            try:
                new_value = sthani.value + term_value[1:]
            except AttributeError:
                new_value = sthani + term_value[1:]

        elif isinstance(sthani, basestring):
            # 1.1.52 alo 'ntyasya
            # 1.1.55 anekālśit sarvasya
            if len(sthani) <= 1:
                new_value = term_value[:-1] + sthani
            else:
                new_value = sthani

        elif not hasattr(sthani, 'value'):
            # 1.1.50 sthāne 'ntaratamaḥ
            last = Sound(term.antya).closest(sthani)
            new_value = term_value[:-1] + last

        # 1.1.47 mid aco 'ntyāt paraḥ
        elif 'mit' in sthani.samjna:
            ac = Sounds('ac')
            for i, L in enumerate(reversed(term_value)):
                if L in ac:
                    break
            new_value = term_value[:-i] + sthani.value + term_value[-i:]
            add_part = True

        # 1.1.46 ādyantau ṭakitau
        elif 'kit' in sthani.samjna:
            new_value = term_value + sthani.value
            add_part = True
        elif 'wit' in sthani.samjna:
            new_value = sthani.value + term_value
            add_part = True

        # 1.1.52 alo 'ntyasya
        # 1.1.53 ṅic ca
        elif len(sthani.value) == 1 or 'Nit' in sthani.samjna:
            new_value = term_value[:-1] + sthani.value

        # 1.1.55 anekālśit sarvasya
        elif 'S' in sthani.it or len(sthani.value) > 1:
            new_value = sthani.value

        if new_value is not None:
            new_term = term.set_at(locus, new_value)
            if add_part:
                new_term = new_term.add_part(sthani.raw)
            return state.swap(index, new_term)

        raise NotImplementedError(sthani)
Exemplo n.º 16
0
def run_game():
    # Initialize pygame, settings, screen object, music channel
    pygame.init()
    sounds = Sounds()

    # Limit FPS
    clock = pygame.time.Clock()

    ai_settings = Settings()
    screen = pygame.display.set_mode(
        (ai_settings.screen_width, ai_settings.screen_height))

    pygame.display.set_caption("Alien Invasion")

    # Create an instance to store game statistics and create a scoreboard.
    stats = GameStats(ai_settings)
    sb = Scoreboard(ai_settings, screen, stats)

    # Create the start and highscore screen
    start_screen = StartScreen(ai_settings, screen)
    hs_screen = HighScoreScreen(ai_settings, screen, stats)

    # Make a ship, a group of ship_bullets, and a group of aliens
    ship = Ship(screen, ai_settings)
    ship_bullets = Group()
    aliens = Group()
    alien_bullets = Group()
    bunkers = Group()

    # Create the fleet of aliens and row of bunkers
    gf.create_fleet(ai_settings, screen, ship, aliens)
    gf.create_bunker_row(ai_settings, screen, ship, bunkers)

    # Start the main loop for the game
    while True:

        # Limit FPS
        clock.tick(60)

        # Watch for keyboard/mouse events
        gf.check_events(ai_settings, screen, stats, sb, start_screen, ship,
                        aliens, ship_bullets, sounds, bunkers, hs_screen)

        if stats.game_active:
            ship.update(stats.ships_left)
            ship_bullets.update()
            alien_bullets.update()
            bunkers.update()

            gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
                              bunkers, ship_bullets, alien_bullets, sounds)
            gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens,
                             ship_bullets, alien_bullets, sounds)

        # Redraw the screen during each pass through the loop.
        # Make the most recently drawn screen visible
        gf.update_screen(ai_settings, screen, stats, sb, ship, aliens,
                         ship_bullets, alien_bullets, start_screen, bunkers,
                         hs_screen)
Exemplo n.º 17
0
    def __init__(self):
        """Инициализирует игру и создает игровые ресурсы."""
        self.settings = Settings()
        # Функция pri_init должна вызываться до pygame.init
        pygame.mixer.pre_init(44100, -16, 1, 512)
        pygame.init()
        # Инициируем методы трансляции звуков в игре
        # pygame.mixer.init()
        self.screen = pygame.display.set_mode(
            (self.settings.screen_width, self.settings.screen_height))
        pygame.display.set_caption("Alien Invasion")
        #pygame.display.set_icon(pygame.image.load("app.bmp"))

        # Загрузим фоновое изображение
        self.bg = pygame.image.load('images/StarFon1280x905.jpg')
        # Масштабируем изображение по величине игровой поверхности
        self.bg = pygame.transform.scale(
            self.bg, (self.settings.screen_width, self.settings.screen_height))
        # Задаём что левый верхний угол изображения должен совпадать с углом экрана игры
        self.bg_rect = self.bg.get_rect(topleft=(0, 0))
        self.volume = 1.0
        #Загружаем музыку и звуки
        bg_music = Sounds('sounds/alarm.mp3')
        bg_music.playing_music()
        # Созданим несколько звёзд, которые случайным образом будут располагаться на небе.
        self.star_image = 'images/Star40x40.png'
        self._create_Stars(self.star_image)
        # Создаём группу для отрисовки взрывов
        self.explosions = pygame.sprite.Group()
        # Создаём экземпляр класса Animation.
        self.explosion = Animation((100, 100), 'images/explosions/explosion',
                                   30)
        # Создаём группу спрайтов для отрисовки снарядов, это своего рода список с расширенной функциональностью
        self.bullets = pygame.sprite.Group()
        # Создаём группу пришельцев. Их отображение будет реализовано методами группы Pygame
        self.aliens = pygame.sprite.Group()
        # Создание экземпляра для хранения игровой статистики и панели результатов
        self.stats = GameStats(self)
        self.sb = Scoreboard(self)
        # Создаём объект ship, передав конструктору класса указатель на экземпляр класса AlienInvasion
        self.ship = Ship(self)
        self._create_fleet()
        # Создаём объект времени в игре
        self.clock = pygame.time.Clock()
        # Создание кнопки Play.
        self.play_button = Button(self, "Play")
Exemplo n.º 18
0
 def __init__(self, screen, score_controller, transition_time=5000):
     self.screen = screen
     self.score_controller = score_controller
     self.sound = Sounds(['pacman-beginning.wav'],
                         keys=['transition'],
                         channel=NextLevel.audio,
                         volume=0.6)
     self.font = pygame.font.Font('fonts/LuckiestGuy-Regular.ttf', 32)
     self.ready_msg = self.font.render('Get Ready!', True, Scoreboard.white)
     self.ready_msg_rect = self.ready_msg.get_rect()
     ready_pos = screen.get_width() // 2, int(screen.get_height() * 0.65)
     self.ready_msg_rect.centerx, self.ready_msg_rect.centery = ready_pos
     self.level_msg = None
     self.level_msg_rect = None
     self.transition_time = transition_time
     self.transition_begin = None
     self.transition_show = False
Exemplo n.º 19
0
def samyogapurva(term):
    """Filter on whether a term's final sound follows a conjunct."""
    value = term.value
    hal = Sounds('hal')
    try:
        return value[-3] in hal and value[-2] in hal
    except IndexError:
        return False
Exemplo n.º 20
0
 def __init__(self):
     self.bg = pygame.image.load("images/bg.jpg")
     self.bg = pygame.transform.scale(self.bg,
                                      (SCREEN_WIDTH, SCREEN_HEIGHT))
     self.bgrect = self.bg.get_rect()
     self.ball = Ball()
     self.human = Human()
     self.robot = Robot()
     self.goal = Goal(0)
     self.win = Win(0)
     self.lose = Lose(0)
     self.menu = Menu()
     self.mouse = (0, 0)
     self.sounds = Sounds()
     self.sounds.music()
     self.status = Game.MENU
     self.reset()
Exemplo n.º 21
0
 def check_msg(correct, solution, next_ex, celebrate=False):
     if correct:
         if celebrate:
             return 'Very good! ' + solution + '<break time="1s"/>' + Sounds.celebration() + '<break time="1s"/>' + Helper.congrats() + Helper.ex_ask_msg()
         else:
             return 'Very good! ' + solution + '. Here comes the next exercise: <break time="1s"/> ' + next_ex
     else:
         return 'I think this was wrong. Correct answer is ' + solution + '. Here comes the next exercise:  <break time="1s"/>' + next_ex
Exemplo n.º 22
0
def samyogadi(term):
    """Filter on whether a term begins with a conjunct."""
    value = term.value
    hal = Sounds('hal')
    try:
        return value[0] in hal and value[1] in hal
    except IndexError:
        return False
Exemplo n.º 23
0
def ekac(term):
    seen = False
    ac = Sounds('ac')
    for L in term.value:
        if L in ac:
            if seen:
                return False
            seen = True
    return True
Exemplo n.º 24
0
def load_new_exercise_data():
    ex_obj = random.choice(ex_iv)
    session.attributes['solution_verbform'] = ex_obj['answer']
    session.attributes['solution_sentence'] = "%s %s %s" % (
        ex_obj['sentence_front'], ex_obj['answer'], ex_obj['sentence_back'])
    session.attributes['task'] = "%s, %s, %s" % (
        ex_obj['verb'], ex_obj['tense'],
        ex_obj['sentence_front'] + Sounds.beep() + ex_obj['sentence_back'])
    session.attributes['HelpLeadsTo'] = ex_obj['tense']
Exemplo n.º 25
0
class NextLevel:
    audio = 4

    def __init__(self, screen, score_controller, transition_time=5000):
        self.screen = screen
        self.score_controller = score_controller
        self.sound = Sounds(['pacman-beginning.wav'],
                            keys=['transition'],
                            channel=NextLevel.audio,
                            volume=0.6)
        self.font = pygame.font.Font('fonts/LuckiestGuy-Regular.ttf', 32)
        self.ready_msg = self.font.render('Get Ready!', True, Scoreboard.white)
        self.ready_msg_rect = self.ready_msg.get_rect()
        ready_pos = screen.get_width() // 2, int(screen.get_height() * 0.65)
        self.ready_msg_rect.centerx, self.ready_msg_rect.centery = ready_pos
        self.level_msg = None
        self.level_msg_rect = None
        self.transition_time = transition_time
        self.transition_begin = None
        self.transition_show = False

    def prep_level_msg(self):
        text = 'level ' + str(self.score_controller.level)
        self.level_msg = self.font.render(text, True, Scoreboard.white)
        self.level_msg_rect = self.level_msg.get_rect()
        level_pos = self.screen.get_width() // 2, self.screen.get_height() // 2
        self.level_msg_rect.centerx, self.level_msg_rect.centery = level_pos

    def set_show_transition(self):
        self.prep_level_msg()
        self.transition_begin = pygame.time.get_ticks()
        self.transition_show = True
        self.sound.play('transition')

    def draw(self):
        if abs(self.transition_begin -
               pygame.time.get_ticks()) > self.transition_time:
            self.transition_show = False
        else:
            self.screen.fill((0, 0, 0))
            self.screen.blit(self.level_msg, self.level_msg_rect)
            if abs(self.transition_begin -
                   pygame.time.get_ticks()) >= self.transition_time // 2:
                self.screen.blit(self.ready_msg, self.ready_msg_rect)
Exemplo n.º 26
0
    def __kill_entities(self, entity_lst, i=0):
        if i == len(entity_lst):
            return

        if entity_lst[i].isDead():
            entity_lst.remove(entity_lst[i])
            Sounds().death.play()
            self.__kill_entities(entity_lst, i)
        else:
            self.__kill_entities(entity_lst, i + 1)
Exemplo n.º 27
0
 def __init__(self, w, h):
     pygame.init()
     self.size = w, h
     self.screen = pygame.display.set_mode(self.size)
     pygame.display.set_caption(TITLE)
     pygame.display.flip()
     self.hero_is_died = pygame.sprite.Sprite()
     self.hero_is_died.image = pygame.image.load("data/hero_died.png")
     self.hero_is_died.rect = self.hero_is_died.image.get_rect()
     self.hero_is_win = pygame.sprite.Sprite()
     self.hero_is_win.image = pygame.image.load("data/win.png")
     self.hero_is_win.rect = self.hero_is_died.image.get_rect()
     self.dead = pygame.sprite.Group()
     self.win_sp = pygame.sprite.Group()
     self.hero_is_win.add(self.win_sp)
     self.hero_is_died.add(self.dead)
     self.camera = Camera(w, h)
     self.win_m, self.dead_m = False, False
     self.music = [
         pygame.mixer.Sound("data/background_music_1.ogg"),
         pygame.mixer.Sound("data/background_music_2.ogg"),
         pygame.mixer.Sound("data/background_music_3.ogg")
     ]
     self.menu_music = pygame.mixer.Sound("data/music/main_menu.ogg")
     self.victory_music = pygame.mixer.Sound("data/Victory.wav")
     self.dead_music = pygame.mixer.Sound("data/dead.wav")
     self.menu_music.play(-1)
     self.hero_sprite = pygame.sprite.Group()
     self.enemy_sprites = pygame.sprite.Group()
     self.boss_sprite = pygame.sprite.Group()
     self.platform_sprites = pygame.sprite.Group()
     self.all_sprites = pygame.sprite.Group()
     self.princess_sprite = pygame.sprite.Group()
     self.info_sprites = pygame.sprite.Group()
     self.background_sprite = pygame.sprite.Group()
     self.buttons = pygame.sprite.Group()
     self.level_names = ["intro", "1", "2", "final"]
     self.level_state = 0
     self.new_game_btn = Button(self.buttons, "new_game_btn.png",
                                "new_game_btn_2.png", 208, 93,
                                "bookFlip2.ogg", "new_game")
     self.hero = Hero(self.hero_sprite, 60, 60,
                      Sounds().return_dict_of_sounds())
     self.hero.add(self.all_sprites)
     self.cursor_group = pygame.sprite.Group()
     self.cursor = Cursor(self.cursor_group)
     self.main_menu = True
     self.bg = Background(self.background_sprite)
     self.main_img = pygame.image.load("data/main_menu.png")
     pygame.mouse.set_visible(False)
     self.clock = pygame.time.Clock()
     self.fps = 40
     self.just_music = None
     self.left_state, self.up_state, self.attack = None, None, None
     self.running = True
Exemplo n.º 28
0
    def setup(self):
        """
        Called once at the start
        :return: none
        """
        # open window
        arcade.open_window(self.WINDOW_WIDTH, self.WINDOW_HEIGHT, "Main")
        arcade.schedule(self.on_update, 1 / 60)
        arcade.set_background_color(arcade.color.BLACK)

        # setting up rooms
        self.tile_map = TiledMap()
        self.rooms = []
        room = self.tile_map.tutorial_world()
        self.rooms.append(room)

        room = self.tile_map.stage_one()
        self.rooms.append(room)

        room = self.tile_map.stage_two()
        self.rooms.append(room)

        room = self.tile_map.stage_three()
        self.rooms.append(room)

        room = self.tile_map.boss_world()
        self.rooms.append(room)
        self.room_tutorial()
        # add start screen
        self.transition = arcade.load_texture("images/start_screen.png")
        # add sounds
        self.sound = Sounds()
        self.sound.update(1)
        # override arcade methods
        self.level_finish_time = 0
        self.game_over = False
        window = arcade.get_window()
        window.on_key_press = self.on_key_press
        window.on_key_release = self.on_key_release
        window.on_draw = self.on_draw
        arcade.finish_render()
        arcade.run()
Exemplo n.º 29
0
    def __init__(self):
        ## initialize game
        pygame.init()
        self.settings = Settings()
        self.screen = pygame.display.set_mode(
            (self.settings.screen_width, self.settings.screen_height))
        pygame.display.set_caption("Alien Invasion")

        self.stars = pygame.sprite.Group()
        self._create_sky()
        self.stats = GameStats(self)
        self.sb = Scoreboard(self)
        self.ship = Ship(self)
        self.bullets = pygame.sprite.Group()
        self.aliens = pygame.sprite.Group()
        self.snd = Sounds()
        self.snd.start_bg_music()

        self._create_fleet()
        self.play_button = Button(self, "Play")
Exemplo n.º 30
0
 def __select(self, menu: Menu):
     if self.__choice == 0:
         self.is_active = False
         pygame.mixer.music.unpause()
     elif self.__choice == 1:
         self.section = 'save'
     elif self.__choice == 2:
         menu.is_active = True
         self.is_active = False
     self.__choice = 0
     Sounds().select.play()
Exemplo n.º 31
0
    def __init__(self):
        pygame.mixer.pre_init(44100,-16,2,2048)
        pygame.init()

        self.sounds=Sounds()


        self.input_handler = InputHandler()
        self.game_screen = GameScreen(self.TITLE,self.WIDTH,self.HEIGHT)
        self.miner=Miner(8,0)
        self.explosion=Explosion(-1,-1)
        self.game_screen.add_sprite(self.miner)
        self.game_screen.add_sprite(self.explosion)
        self.health = 100
         
        self.clock=pygame.time.Clock()
        self.state=self.WAITING
        self.game_screen.display_opening()
Exemplo n.º 32
0
class StartQT4(QtGui.QMainWindow):
    def __init__(self, parent = None):
        QtGui.QWidget.__init__(self, parent)
        self.ui = Ui_mainWindow()
        self.ui.setupUi(self)

        # Force consistent theme and font size
        QtGui.QApplication.setStyle(QtGui.QStyleFactory.create("Plastique"))
        self.setStyleSheet("font-size: 11pt")

        # Disable resizing
        self.setFixedSize(self.size())

        # Disable settings frame until a set is selected
        self.ui.frame.setEnabled(False)
        self.msg("Enabling frame.")

        # Clear lists
        self.ui.listSets.clear()
        self.ui.listPhonemes.clear()

        # Indices of objects currently selected in the interface
        self.levelIndex = 0
        self.setIndex = None
        self.phonemeIndex = None

        # Instantiate all levels
        self.levels = []
        for n in range(0, NUM_LEVELS):
            self.levels.append(Level())
            self.msg("Adding level " + str(n+1))
            
        # Update the displayed list of sets
        self.update_sets()
        self.msg("Updating set list.")
        
        # Display images
        self.show_images()

        #######################################################
        # Interface Object Connections                        #
        #######################################################
        itemClicked = QtCore.SIGNAL("itemClicked(QListWidgetItem *)")
        clicked = QtCore.SIGNAL("clicked()")

        ## List Widgets
        QtCore.QObject.connect(self.ui.listSets, itemClicked, self.select_set)
        QtCore.QObject.connect(self.ui.listPhonemes,itemClicked, self.select_phoneme)

        ## Buttons
        QtCore.QObject.connect(self.ui.btnAddSet, clicked, self.add_set)
        QtCore.QObject.connect(self.ui.btnRemoveSet, clicked, self.remove_set)
        QtCore.QObject.connect(self.ui.btnAddPhoneme, clicked, self.add_phoneme)
        QtCore.QObject.connect(self.ui.btnRemovePhoneme, clicked, self.remove_phoneme)
        QtCore.QObject.connect(self.ui.btnSetGoal, clicked, self.set_goal)
        QtCore.QObject.connect(self.ui.btnLoadImage, clicked, self.load_image)
        QtCore.QObject.connect(self.ui.btnModifySounds, clicked, self.modify_sounds)
        QtCore.QObject.connect(self.ui.btnSave, clicked, self.save)
        QtCore.QObject.connect(self.ui.btnLoad, clicked, self.load)
        QtCore.QObject.connect(self.ui.btnInstall, clicked, self.install)
        QtCore.QObject.connect(self.ui.btnCustom, clicked, self.custom_sound)

        QtCore.QObject.connect(self.ui.btnA, clicked, self.a)
        QtCore.QObject.connect(self.ui.btnO, clicked, self.o)
        QtCore.QObject.connect(self.ui.btnEU, clicked, self.eu)
        QtCore.QObject.connect(self.ui.btnE_grave, clicked, self.e_grave)
        QtCore.QObject.connect(self.ui.btnE_acute, clicked, self.e_acute)
        QtCore.QObject.connect(self.ui.btnE, clicked, self.e)
        QtCore.QObject.connect(self.ui.btnI, clicked, self.i)
        QtCore.QObject.connect(self.ui.btnU, clicked, self.u)
        QtCore.QObject.connect(self.ui.btnOU, clicked, self.ou)
        QtCore.QObject.connect(self.ui.btnAN, clicked, self.an)
        QtCore.QObject.connect(self.ui.btnON, clicked, self.on)
        QtCore.QObject.connect(self.ui.btnUN, clicked, self.un)
        QtCore.QObject.connect(self.ui.btnIN, clicked, self.in2)
        QtCore.QObject.connect(self.ui.btnUI, clicked, self.ui2)
        QtCore.QObject.connect(self.ui.btnILL, clicked, self.ill)
        QtCore.QObject.connect(self.ui.btnOI, clicked, self.oi)
        QtCore.QObject.connect(self.ui.btnP, clicked, self.p)
        QtCore.QObject.connect(self.ui.btnB, clicked, self.b)
        QtCore.QObject.connect(self.ui.btnF, clicked, self.f)
        QtCore.QObject.connect(self.ui.btnV, clicked, self.v)
        QtCore.QObject.connect(self.ui.btnM, clicked, self.m)
        QtCore.QObject.connect(self.ui.btnR, clicked, self.r)
        QtCore.QObject.connect(self.ui.btnT, clicked, self.t)
        QtCore.QObject.connect(self.ui.btnD, clicked, self.d)
        QtCore.QObject.connect(self.ui.btnS, clicked, self.s)
        QtCore.QObject.connect(self.ui.btnZ, clicked, self.z)
        QtCore.QObject.connect(self.ui.btnN, clicked, self.n)
        QtCore.QObject.connect(self.ui.btnL, clicked, self.l)
        QtCore.QObject.connect(self.ui.btnK, clicked, self.k)
        QtCore.QObject.connect(self.ui.btnG, clicked, self.g)
        QtCore.QObject.connect(self.ui.btnCH, clicked, self.ch)
        QtCore.QObject.connect(self.ui.btnJ, clicked, self.j)
        QtCore.QObject.connect(self.ui.btnGN, clicked, self.gn)

        ## Others
        QtCore.QObject.connect(self.ui.txtNewPhoneme,
                               QtCore.SIGNAL("textChanged(const QString&)"),
                               self.check_new_phoneme)
        QtCore.QObject.connect(self.ui.txtNewPhoneme,
                               QtCore.SIGNAL("returnPressed()"),
                               self.press_enter)
        QtCore.QObject.connect(self.ui.verticalSlider,
                               QtCore.SIGNAL("valueChanged(int)"),
                               self.change_level)
        QtCore.QObject.connect(self.ui.sldrFailedAttempts,
                               QtCore.SIGNAL("valueChanged(int)"),
                               self.update_sliders)
        QtCore.QObject.connect(self.ui.sldrHintsRequested,
                               QtCore.SIGNAL("valueChanged(int)"),
                               self.update_sliders)
        QtCore.QObject.connect(self.ui.sldrTime,
                               QtCore.SIGNAL("valueChanged(int)"),
                               self.update_sliders)


    # Updates the displayed list of sets with the internal list.
    def update_sets(self):
        # get the list of sets in the selected level
        level = self.get_level()
        levelSets = level.sets

        # clear the displayed sets
        self.ui.listSets.clear()
        self.msg("Clearing set list.")

        # add each set to the list
        index = 1
        for item in levelSets:
            self.ui.listSets.addItem("Set " + str(index))
            self.msg("Adding set index " + str(index))
            index += 1
        
        # disable 'remove set' button if necessary
        if len(levelSets) < 2:
            self.ui.btnRemoveSet.setEnabled(False)
            self.msg("Disabling remove set button. (sets = " + str(len(levelSets)) + ")")
        else:
            self.ui.btnRemoveSet.setEnabled(True)
            self.msg("Enabling remove set button. (sets = " + str(len(levelSets)) + ")")

    # This function is called when the user selects a set from the list
    def select_set(self, item):
        # show frame if it isn't there already
        self.ui.frame.setEnabled(True)

        # get the index of the selected item
        index = self.set_index(item)

        # remember index
        self.setIndex = index

        # load phonemes from the current set
        self.update_phonemes()

        # clear current phoneme and current goal
        self.phonemeIndex = None

        # disable phoneme-specific ui elements
        self.reset_phoneme_ui()

        # debug string
        currentSet = self.get_set()
        string = "Selecting set at index " + str(index) + ":" 
        string += currentSet.toString()
        self.msg(string)

    # This function removes phoneme-specific content from the UI
    def reset_phoneme_ui(self):
        self.ui.btnRemovePhoneme.setEnabled(False)
        self.ui.btnSetGoal.setEnabled(False)
        self.ui.soundsGroup.setEnabled(False)
        self.ui.imageGroup.setEnabled(False)
        self.ui.lblSoundPath.clear()
        self.ui.lblImagePath = ""
        self.ui.imgPhoneme.clear()
        
    # Enables phoneme-specific content in the UI
    def enable_phoneme_ui(self):
        self.ui.btnRemovePhoneme.setEnabled(True)
        self.ui.btnSetGoal.setEnabled(True)
        self.ui.soundsGroup.setEnabled(True)
        self.ui.imageGroup.setEnabled(True)

    # Updates the phoneme lists
    def update_phonemes(self):
        # clear phoneme list
        self.ui.listPhonemes.clear()

        # add phonemes into appropriate lists
        phonemes = self.get_set().phonemes
        if phonemes != None:
            for p in range(0, len(phonemes)):
                # get current phoneme
                phoneme = phonemes[p]
                if phoneme.goal:
                    self.ui.listPhonemes.addItem(phoneme.name + " (GOAL)")
                else:
                    self.ui.listPhonemes.addItem(phoneme.name)
    
    # This function is called whenever the user selects an items from the phoneme list
    def select_phoneme(self, phoneme):
        # enable 'make goal' button
        self.enable_phoneme_ui()

        # get the index of the selected item
        index = self.phoneme_index(phoneme)

        # remember index
        self.phonemeIndex = index

        # Enable phoneme sounds and load image button
        self.ui.soundsGroup.setEnabled(True)
        self.ui.btnLoadImage.setEnabled(True)

        self.ui.lblSoundPath.clear()

        # Update interface with phoneme information
        p = self.get_phoneme()
        self.msg("Index: " + str(index))
        self.msg("Selected phoneme at index " + str(index) + ":\n" + p.toString())
        if p.image_path != "":
            self.ui.lblImagePath = p.image_path
            self.ui.imgPhoneme.setPixmap(QtGui.QPixmap(p.image_path))
        else:
            self.ui.lblImagePath = ""
            self.ui.imgPhoneme.clear()
        self.select_sound(p.text)

        # Select appropriate sound
        self.select_sound(p.text)

    # Enables or disables the 'add phoneme' button as necessary
    def check_new_phoneme(self, text):
        # ensure text isn't blank
        if text != "":
            # ensure text is unique
            uniqueName = True
            currentSet = self.get_set()
            phonemes = currentSet.phonemes
            if phonemes != None:
                for p in range(0, len(phonemes)):
                    phoneme = phonemes[p]
                    if phoneme.name == str(text):
                        uniqueName = False
            if uniqueName:
                self.ui.btnAddPhoneme.setEnabled(True)
            else:
                self.ui.btnAddPhoneme.setEnabled(False)
        else:
            self.ui.btnAddPhoneme.setEnabled(False)

    # Enter key while editing new phoneme text functionality
    def press_enter(self):
        if self.ui.btnAddPhoneme.isEnabled():
            self.add_phoneme()

    # Loads an image into the interface and saves it into the phoneme object
    def load_image(self):
        phoneme = self.get_phoneme()
        phoneme.image_path = str(QtGui.QFileDialog.getOpenFileName())
        phoneme.image_file = basename(phoneme.image_path)

        self.ui.imgPhoneme.setPixmap(QtGui.QPixmap(phoneme.image_path))
        self.ui.lblImagePath = phoneme.image_file

    # Returns the currently selected level
    def get_level(self):
        return self.levels[self.levelIndex]

    # Returns the currently selected set
    def get_set(self):
        level = self.levels[self.levelIndex]
        if self.setIndex != None:
            return level.sets[self.setIndex]
        else:
            return None

    # Returns the currently selected phoneme
    def get_phoneme(self):
        set = self.get_set()
        if self.phonemeIndex != None:
            return set.phonemes[self.phonemeIndex]
        else:
            return None
        
    # Returns the index of a given set as an integer.
    def set_index(self, item):
        return int(item.text()[4:]) - 1 # get text from set string
    
    # Returns the index of a given phoneme as an integer.
    def phoneme_index(self, item):
        currentSet = self.get_set()
        phonemes = currentSet.phonemes
        for i in range(0, len(phonemes)):
            phoneme = phonemes[i]
            self.msg("Phoneme name: " + str(phoneme.name))
            self.msg("Item text: " + str(item.text()))
            self.msg("Item text [:-7]: " + str(item.text())[:-7])
            if str(phoneme.name) == str(item.text()):
                self.msg("Item text == phoneme name")
                return i
            elif str(phoneme.name) == str(item.text())[:-7]:
                self.msg("Item text + goal == phoneme name")
                return i
        return None

    # Adds a set to the currently selected level
    def add_set(self):
        level = self.get_level()
        self.msg("Adding set.")
        level.add_set()
        self.update_sets()

    # Removes a set from the currently selected level
    def remove_set(self):
        if self.setIndex != None:
            level = self.get_level()
            self.msg("Removing set at index " + str(self.setIndex))
            level.remove_set(self.setIndex)
            self.update_sets()

    # Adds a phoneme to the currently selected set
    def add_phoneme(self):
        if self.get_num_phonemes() <= MAX_PHONEMES:
            # build phoneme
            phoneme = Phoneme()
            phoneme.name = str(self.ui.txtNewPhoneme.text())

            # clear input text
            self.ui.txtNewPhoneme.clear()

            # add phoneme to set
            currentSet = self.get_set()
            self.msg("Adding phoneme " + phoneme.name)
            currentSet.add_phoneme(phoneme)
            self.msg("Current set: " + currentSet.toString())

            # update phoneme list
            self.update_phonemes()
        else:
            QtGui.QMessageBox.warning(self,
                                   "Phoneme Limit Reached",
                                   "You have reached the limit of " + str(MAX_PHONEMES) + " phonemes.\nPlease remove some existing phonemes to add new ones.")

    # Removes a phoneme from the currently selected set
    def remove_phoneme(self):
        if self.phonemeIndex != None:
            currentSet = self.get_set()
            self.msg("Removing phoneme at index " + str(self.phonemeIndex))
            currentSet.remove_phoneme(self.phonemeIndex)
            self.reset_phoneme_ui()
            self.update_phonemes()

    # Returns the number of phonemes currently in the game.
    def get_num_phonemes(self):
        n = 0
        for level in self.levels:
            for set in level.sets:
                for phoneme in set.phonemes:
                    n += 1
        return n
                    
            
    # Sets the currently selected phoneme as the goal for the set
    def set_goal(self):
        if self.phonemeIndex != None:
            currentSet = self.get_set()
            currentSet.set_goal_index(self.phonemeIndex)
            self.update_phonemes()

    # Loads the phoneme sound modification inderface
    def modify_sounds(self):
        # load up sounds UI
        self.Sounds = Sounds(self)
        self.Sounds.show()

    # Print debug messages, if needed
    def msg(self, message):
        if DEBUG:
            print(str(datetime.time(datetime.now())) + " > DEBUG: " + message)

    # Switches the interface to edit another level.
    def change_level(self, newLevel):
        self.msg("Switching to level " + str(newLevel))
        self.levelIndex = newLevel - 1
        self.update_sets()
        self.reset_phoneme_ui()
        self.ui.listPhonemes.clear()

    # Updates the sound paths of all phonemes using the sounds config file.
    def update_sound_paths(self):
        try:
            # get the collection from the sounds config file
            with open("sounds.pk", 'rb') as input:
                collection = pickle.load(input)
                self.msg("Data loaded from sounds.pk.")
                currentSet = self.get_set()
                phonemes = currentSet.phonemes
                # for each phoneme, update the path using the text
                for i in range(0, len(phonemes)):
                    phoneme = phonemes[i]
                    # iterate through every Phoneme_Sound to find a match
                    for ps in collection:
                        if ps.text == phoneme.text:
                            phoneme.sound_path = ps.path
        except:
            self.msg("Warning: sounds config file not found.")

    # Saves the entire configuration as a file using the pickle module.
    # The file contains a single Game() object as defined in phoneme.py.
    # The object consists of a list of levels as well as values for each
    # difficulty slider (failed attempts, hints requested, and time).
    def save(self):
        # construct the game object to save
        game = Game()
        game.levels = self.levels
        game.failedAttemptsWeight = self.ui.sldrFailedAttempts.value()
        game.hintsRequestedWeight = self.ui.sldrHintsRequested.value()
        game.timeWeight = self.ui.sldrTime.value()

        # get path to save file to
        path = QtGui.QFileDialog.getSaveFileName(self, 
                                           "Save File", 
                                           "", 
                                           "Phoneme Awareness Configuration File (*.cfg)")
        path = str(path) + ".cfg"
        try:
            with open(str(path), 'wb') as output:
                pickle.dump(game, output, pickle.HIGHEST_PROTOCOL)
                self.msg("Save successful.")
        except:
            self.msg("Save failed.")

        # additionally, save the slider values into a text file
        #try:
        #    with open("sliders.txt", 'wb') as output:
        #        output.write(str(game.failedAttemptsWeight) + "\n")
        #        output.write(str(game.hintsRequestedWeight) + "\n")
        #        output.write(str(game.timeWeight) + "\n")
        #except:
        #    self.msg("Slider file output failed.")


    # Load button functionality
    def load(self):
        # get path to load file from
        path = str(QtGui.QFileDialog.getOpenFileName(self,
                                                     "Load File",
                                                     "",
                                                     "Phoneme Awareness Configuration File (*.cfg)"))

        # get game object from file
        game = None
        try:
            with open(path, 'rb') as input:
                game = pickle.load(input)
                self.levels = game.levels
                self.ui.sldrFailedAttempts.setValue(game.failedAttemptsWeight)
                self.ui.sldrHintsRequested.setValue(game.hintsRequestedWeight)
                self.ui.sldrTime.setValue(game.timeWeight)
                self.update_sliders()
                self.msg("Settings file loaded successfully.")
                self.update_sets()
        except:
            self.msg("Settings could not be loaded.")

    # Installs the game with the current configuration to the Sifteos
    def install(self):
        # construct the game object
        QtGui.QMessageBox.information(self,
                                      "Starting Installation",
                                      "This will begin installing the game to the Sifteo cubes.\n\nYou will be notified when the installation is complete.")
        try:
            game = Game()
            game.levels = self.levels
            game.failedAttemptsWeight = self.ui.sldrFailedAttempts.value()
            game.hintsRequestedWeight = self.ui.sldrHintsRequested.value()
            game.timeWeight = self.ui.sldrTime.value()
        
            generate_files(game, '..\PhonemeFrenzy')
            compile_elf()
            install_elf()
            QtGui.QMessageBox.information(self,
                                          "Installation Complete",
                                          "The installation is complete.")
        except Exception as e:
            QtGui.QMessageBox.warning(self,
                                "Installation Error",
                                "An error occurred. The following exception was given:\n\n" + str(e))

    
    # Allows the user to define a custom sound file
    def custom_sound(self):
        phoneme = self.get_phoneme()
        path = str(QtGui.QFileDialog.getOpenFileName())
        if path != "":
            phoneme.sound_path = path
            phoneme.text = "custom"
            self.lblSoundPath.setText(basename(path))
        
    # Updates the displayed values for the sliders.
    def update_sliders(self):
        self.ui.lblAttempts.setText(str(self.ui.sldrFailedAttempts.value()) + "%")
        self.ui.lblHints.setText(str(self.ui.sldrHintsRequested.value()) + "%")
        self.ui.lblTimeValue.setText(str(self.ui.sldrTime.value()) + "%")
        
    def show_images(self):
        self.ui.btnRemoveSet.setIcon(QtGui.QIcon("minus.png"))
        self.ui.btnAddSet.setIcon(QtGui.QIcon("plus.png"))
        self.ui.btnRemovePhoneme.setIcon(QtGui.QIcon("minus.png"))
        self.ui.btnAddPhoneme.setIcon(QtGui.QIcon("plus.png"))
        
    # Individual phoneme sound button functions
    def a(self):
        self.select_sound("a")
    def o(self):
        self.select_sound("o")
    def eu(self):
        self.select_sound("eu")
    def e_grave(self):
        self.select_sound("e_grave")
    def e_acute(self):
        self.select_sound("e_acute")
    def e(self):
        self.select_sound("e")
    def i(self):
        self.select_sound("i")
    def u(self):
        self.select_sound("u")
    def ou(self):
        self.select_sound("ou")
    def an(self):
        self.select_sound("an")
    def on(self):
        self.select_sound("on")
    def un(self):
        self.select_sound("un")
    def in2(self):
        self.select_sound("in")
    def ui2(self):
        self.select_sound("ui")
    def ill(self):
        self.select_sound("ill")
    def oi(self):
        self.select_sound("oi")
    def p(self):
        self.select_sound("p")
    def b(self):
        self.select_sound("b")
    def f(self):
        self.select_sound("f")
    def v(self):
        self.select_sound("v")
    def m(self):
        self.select_sound("m")
    def r(self):
        self.select_sound("r")
    def t(self):
        self.select_sound("t")
    def d(self):
        self.select_sound("d")
    def s(self):
        self.select_sound("s")
    def z(self):
        self.select_sound("z")
    def n(self):
        self.select_sound("n")
    def l(self):
        self.select_sound("l")
    def k(self):
        self.select_sound("k")
    def g(self):
        self.select_sound("g")
    def ch(self):
        self.select_sound("ch")
    def j(self):
        self.select_sound("j")
    def gn(self):
        self.select_sound("gn")

    # Selects a specific sound button
    def select_sound(self, s):
        self.deselect_all()
        if s == "a":
            self.ui.btnA.setChecked(True)
        elif s == "o":
            self.ui.btnO.setChecked(True)
        elif s == "eu":
            self.ui.btnEU.setChecked(True)
        elif s == "e_grave":
            self.ui.btnE_grave.setChecked(True)
        elif s == "e_acute":
            self.ui.btnE_acute.setChecked(True)
        elif s == "i":
            self.ui.btnI.setChecked(True)
        elif s == "u":
            self.ui.btnU.setChecked(True)
        elif s == "ou":
            self.ui.btnOU.setChecked(True)
        elif s == "an":
            self.ui.btnAN.setChecked(True)
        elif s == "on":
            self.ui.btnON.setChecked(True)
        elif s == "un":
            self.ui.btnUN.setChecked(True)
        elif s == "in":
            self.ui.btnIN.setChecked(True)
        elif s == "ui":
            self.ui.btnUI.setChecked(True)
        elif s == "ill" or s == "y":
            self.ui.btnILL.setChecked(True)
        elif s == "oi" or s == "w":
            self.ui.btnOI.setChecked(True)
        elif s == "p":
            self.ui.btnP.setChecked(True)
        elif s == "b":
            self.ui.btnB.setChecked(True)
        elif s == "f":
            self.ui.btnF.setChecked(True)
        elif s == "v":
            self.ui.btnV.setChecked(True)
        elif s == "m":
            self.ui.btnM.setChecked(True)
        elif s == "r":
            self.ui.btnR.setChecked(True)
        elif s == "t":
            self.ui.btnT.setChecked(True)
        elif s == "d":
            self.ui.btnD.setChecked(True)
        elif s == "s":
            self.ui.btnS.setChecked(True)
        elif s == "z":
            self.ui.btnZ.setChecked(True)
        elif s == "n":
            self.ui.btnN.setChecked(True)
        elif s == "l":
            self.ui.btnL.setChecked(True)
        elif s == "k":
            self.ui.btnK.setChecked(True)
        elif s == "g":
            self.ui.btnG.setChecked(True)
        elif s == "ch":
            self.ui.btnCH.setChecked(True)
        elif s == "j":
            self.ui.btnJ.setChecked(True)
        elif s == "gn":
            self.ui.btnGN.setChecked(True)

        # update current phoneme sound
        if s != "":
            phoneme = self.get_phoneme()
            phoneme.text = s
            self.update_sound_paths()
            self.ui.lblSoundPath.setText(basename(phoneme.sound_path))
            sound = QtGui.QSound(phoneme.sound_path)
            sound.play()

    # Deselects all sound buttons in the phoneme sounds section
    def deselect_all(self):
        self.ui.btnA.setChecked(False)
        self.ui.btnO.setChecked(False)
        self.ui.btnEU.setChecked(False)
        self.ui.btnE_grave.setChecked(False)
        self.ui.btnE_acute.setChecked(False)
        self.ui.btnE.setChecked(False)
        self.ui.btnI.setChecked(False)
        self.ui.btnU.setChecked(False)
        self.ui.btnOU.setChecked(False)
        self.ui.btnAN.setChecked(False)
        self.ui.btnON.setChecked(False)
        self.ui.btnUN.setChecked(False)
        self.ui.btnIN.setChecked(False)
        self.ui.btnUI.setChecked(False)
        self.ui.btnILL.setChecked(False)
        self.ui.btnOI.setChecked(False)
        self.ui.btnP.setChecked(False)
        self.ui.btnB.setChecked(False)
        self.ui.btnF.setChecked(False)
        self.ui.btnV.setChecked(False)
        self.ui.btnM.setChecked(False)
        self.ui.btnR.setChecked(False)
        self.ui.btnT.setChecked(False)
        self.ui.btnD.setChecked(False)
        self.ui.btnS.setChecked(False)
        self.ui.btnZ.setChecked(False)
        self.ui.btnN.setChecked(False)
        self.ui.btnL.setChecked(False)
        self.ui.btnK.setChecked(False)
        self.ui.btnG.setChecked(False)
        self.ui.btnCH.setChecked(False)
        self.ui.btnJ.setChecked(False)
        self.ui.btnGN.setChecked(False)
Exemplo n.º 33
0
	def __init__(self):

		print "Arranca Domotics"

		#Configuramos el los pines GPIO
		GPIO.setwarnings(False)

		GPIO.setmode(GPIO.BCM)

		GPIO.setup(deviceConfig.pinResetButton, GPIO.IN, pull_up_down=GPIO.PUD_UP) 
		GPIO.setup(deviceConfig.pinIRSensor, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

		self.leds = Leds()
		#Cuando se encienda el dispositivo se encenderan todos los leds
		self.leds.setLedsOn()

		self.sounds = Sounds()

		#Configuracion del evento para el reset
		GPIO.add_event_detect(deviceConfig.pinResetButton, GPIO.FALLING, callback=self.buttonResetCallback, bouncetime=500)

		time.sleep(1)
		#Una vez pasa 1 segundo se mantiene encendida solo la luz de error hasta que consiga conectarse a internet y montar el servidor
		
		self.leds.setLedsError()

		print "Solicitamos codigo se seguridad"

		self.updateSecurityCode()

		print "¡¡¡Tenemos codigo!!!"

		self.updateVersionDevice(deviceConfig.deviceId)

		self.updateSoftware()

		self.port = int(self.getPort()) #obtenemos el puerto
		print self.port

		self.privateIp = self.getPrivateIp() #Obtenemos la ip privada
		print self.privateIp

		class RequestHandler(pyjsonrpc.HttpRequestHandler):
			# Register public JSON-RPC methods
			methods = {
    			"switchGetValue": self.switchGetValue,
    			"switchSetValue": self.switchSetValue,
        		"sensorGetValues": self.sensorGetValues,
        		"cameraGetPhoto": self.cameraGetPhoto,
        		"cameraGetPhotoForMail": self.cameraGetPhotoForMail,
        		"installRemoteDevice": self.installRemoteDevice,
        		"setDeviceAlarmMode": self.setDeviceAlarmMode,
        		"quitDeviceAlarmMode": self.quitDeviceAlarmMode
    		}

		# Threading HTTP-Server
		http_server = pyjsonrpc.ThreadingHttpServer(
    		server_address = (self.privateIp, self.port),
    		RequestHandlerClass = RequestHandler
		)
		
		print "Creado servidor"

		# Start the scheduler
		sched = Scheduler()
		sched.start()

		# Schedule sendStatus every 1 minutes
		sched.add_interval_job(self.sendStatus, minutes=1)

		# Schedule updateSecurityCode every 1 hours
		sched.add_interval_job(self.updateSecurityCode, hours=1)

		# Schedule updateSoftware every 24 hours
		sched.add_interval_job(self.updateSoftware, hours=24)

		#Obtenemos del servidor el tipo de dispositivo que es y inicializamos
		self.typeDevice = int(self.getTypeDevice())

		print self.typeDevice

		#Remote Device
		if self.typeDevice == 0:

			self.NRF24 = Remote()
			sched.add_interval_job(self.newReadingSensors, hours=1)
			
		#Rele device
		elif self.typeDevice == 1:
			self.rele = Rele()

		#Camera device
		elif self.typeDevice == 2:
			self.camera = Camera()

		#Sensors device
		elif self.typeDevice == 4:

			self.sensors = Sensors()
			sched.add_interval_job(self.newReadingSensors, hours=1)

		print "Actualizamos estado dispositivo"

		## Actualizamos el estado del dispositivo
		self.sendStatus()

		#Temporizador para guadar datos de sensores
		if self.typeDevice == 0 or self.typeDevice == 4:

			self.newReadingSensors()

		#Configuracion del evento para el detector de presencia
		GPIO.add_event_detect(deviceConfig.pinIRSensor, GPIO.RISING, callback=self.IRSensorDetectCallback, bouncetime=10000)
		
		print "Listo para arracar el servidor"

		self.sounds.start()

		#print myconfig.urlDb
		print "Starting HTTP server ..."
		print "URL: http://%s:%d" % (self.privateIp, self.port)

		try:
 			http_server.serve_forever()

		except KeyboardInterrupt:
		    http_server.shutdown()
		    self.leds.setLedsError()

		except:
			self.leds.setLedsError()
			time.sleep(10)
			os.system('sudo reboot')

		print "Stopping HTTP server ..."
Exemplo n.º 34
0
class Device:

	#Sensors
	sensors = 0

	#Remote
	NRF24 = 0 #Remoto
	devicesRemote = [] #Dispositivos remotos

	#Rele
	rele = 0

	#Rele
	camera = 0
	
	#Status
	connectionStatus = 0 #0 offline, 1 online, 2 portNotOpen
	alarmMode = 0 #0 No, 1 Yes

	#Leds
	leds = 0

	#Sounds
	sounds = 0

	#Port and IPs
	port = 0
	publicIp = 0
	privateIp = 0

	#Code security
	currentCode = str(randint(10000,99999999))
	previousCode = currentCode
	numberOfPetitions = 0

	#Type Device
	typeDevice = 0
	

#################################################################################################################################################
#################################################################################################################################################
#####################################################      SECTION DOMOTICS SERVER      #########################################################
#################################################################################################################################################
#################################################################################################################################################

	
	def __init__(self):

		print "Arranca Domotics"

		#Configuramos el los pines GPIO
		GPIO.setwarnings(False)

		GPIO.setmode(GPIO.BCM)

		GPIO.setup(deviceConfig.pinResetButton, GPIO.IN, pull_up_down=GPIO.PUD_UP) 
		GPIO.setup(deviceConfig.pinIRSensor, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

		self.leds = Leds()
		#Cuando se encienda el dispositivo se encenderan todos los leds
		self.leds.setLedsOn()

		self.sounds = Sounds()

		#Configuracion del evento para el reset
		GPIO.add_event_detect(deviceConfig.pinResetButton, GPIO.FALLING, callback=self.buttonResetCallback, bouncetime=500)

		time.sleep(1)
		#Una vez pasa 1 segundo se mantiene encendida solo la luz de error hasta que consiga conectarse a internet y montar el servidor
		
		self.leds.setLedsError()

		print "Solicitamos codigo se seguridad"

		self.updateSecurityCode()

		print "¡¡¡Tenemos codigo!!!"

		self.updateVersionDevice(deviceConfig.deviceId)

		self.updateSoftware()

		self.port = int(self.getPort()) #obtenemos el puerto
		print self.port

		self.privateIp = self.getPrivateIp() #Obtenemos la ip privada
		print self.privateIp

		class RequestHandler(pyjsonrpc.HttpRequestHandler):
			# Register public JSON-RPC methods
			methods = {
    			"switchGetValue": self.switchGetValue,
    			"switchSetValue": self.switchSetValue,
        		"sensorGetValues": self.sensorGetValues,
        		"cameraGetPhoto": self.cameraGetPhoto,
        		"cameraGetPhotoForMail": self.cameraGetPhotoForMail,
        		"installRemoteDevice": self.installRemoteDevice,
        		"setDeviceAlarmMode": self.setDeviceAlarmMode,
        		"quitDeviceAlarmMode": self.quitDeviceAlarmMode
    		}

		# Threading HTTP-Server
		http_server = pyjsonrpc.ThreadingHttpServer(
    		server_address = (self.privateIp, self.port),
    		RequestHandlerClass = RequestHandler
		)
		
		print "Creado servidor"

		# Start the scheduler
		sched = Scheduler()
		sched.start()

		# Schedule sendStatus every 1 minutes
		sched.add_interval_job(self.sendStatus, minutes=1)

		# Schedule updateSecurityCode every 1 hours
		sched.add_interval_job(self.updateSecurityCode, hours=1)

		# Schedule updateSoftware every 24 hours
		sched.add_interval_job(self.updateSoftware, hours=24)

		#Obtenemos del servidor el tipo de dispositivo que es y inicializamos
		self.typeDevice = int(self.getTypeDevice())

		print self.typeDevice

		#Remote Device
		if self.typeDevice == 0:

			self.NRF24 = Remote()
			sched.add_interval_job(self.newReadingSensors, hours=1)
			
		#Rele device
		elif self.typeDevice == 1:
			self.rele = Rele()

		#Camera device
		elif self.typeDevice == 2:
			self.camera = Camera()

		#Sensors device
		elif self.typeDevice == 4:

			self.sensors = Sensors()
			sched.add_interval_job(self.newReadingSensors, hours=1)

		print "Actualizamos estado dispositivo"

		## Actualizamos el estado del dispositivo
		self.sendStatus()

		#Temporizador para guadar datos de sensores
		if self.typeDevice == 0 or self.typeDevice == 4:

			self.newReadingSensors()

		#Configuracion del evento para el detector de presencia
		GPIO.add_event_detect(deviceConfig.pinIRSensor, GPIO.RISING, callback=self.IRSensorDetectCallback, bouncetime=10000)
		
		print "Listo para arracar el servidor"

		self.sounds.start()

		#print myconfig.urlDb
		print "Starting HTTP server ..."
		print "URL: http://%s:%d" % (self.privateIp, self.port)

		try:
 			http_server.serve_forever()

		except KeyboardInterrupt:
		    http_server.shutdown()
		    self.leds.setLedsError()

		except:
			self.leds.setLedsError()
			time.sleep(10)
			os.system('sudo reboot')

		print "Stopping HTTP server ..."


#################################################################################################################################################
#################################################################################################################################################
#####################################################       SECTION INSTALL DEVICE      #########################################################
#################################################################################################################################################
#################################################################################################################################################

	def buttonResetCallback(self, channel):

		print "Reset"

		time.sleep(1)

		if GPIO.input(channel) == GPIO.LOW:

			buttonAlwaysPressed = 1

			for i in range(10):

				if GPIO.input(channel) == GPIO.LOW:
					self.leds.setLedsOn()
					
					time.sleep(0.2)
					self.sounds.on()
					time.sleep(0.1)
					self.sounds.off()
					time.sleep(0.2)
					
					self.leds.setLedsOff()
					
					time.sleep(0.5)

				else:

					buttonAlwaysPressed = 0
			
					
			if GPIO.input(channel) == GPIO.LOW and buttonAlwaysPressed == 1:
						
				self.leds.setLedsAdhoc()

				os.system('sudo cp /home/pi/Domotics/Default/bootInstall.py /home/pi/Domotics/bootConfig.py')
						
				os.system('sudo cp /home/pi/Domotics/Default/network/adhoc/dhcpd.conf /etc/dhcp/dhcpd.conf')
				os.system('sudo cp /home/pi/Domotics/Default/network/adhoc/wpa_supplicant.conf /etc/wpa_supplicant/wpa_supplicant.conf')


				#Eliminamos fichero de configuracion
				os.system('sudo rm /etc/network/interfaces')
				

				nameWIFI = "Domotics%d" % (randint(1000,9999))
				#Creamos el fichero de configuración en base a la plantilla y rellenamos el nombre de la red adhoc
				with open("/etc/network/interfaces", "wt") as fout:
					with open("/home/pi/Domotics/Default/network/adhoc/interfaces", "rt") as fin:
						for line in fin:
							fout.write(line.replace('<NAME>', nameWIFI))


				self.sounds.reset()

				time.sleep(2)

				os.system('sudo reboot')

			else:

				self.leds.updateLeds(self.connectionStatus, self.alarmMode)



	def installRemoteDevice(self, idDevice, pipeSend, pipeRecv, code):


		if (self.currentCode == code or self.previousCode == code) and self.numberOfPetitions < deviceConfig.maxNumberOfPetitions:


			#Eliminamos el software anterior
			os.system('sudo rm /home/pi/Domotics/Arduino/src/domotics.ino')
			
			#Configuramos el nuevo software con el valor del pipeSend y el pipeRecv
			with open("/home/pi/Domotics/Arduino/src/domotics.ino", "wt") as fout:
				with open("/home/pi/Domotics/Default/domoticsAux.ino", "rt") as fin:
					for line in fin:
						fout.write(line.replace('<PIPE_SEND>', pipeSend).replace('<PIPE_RECV>', pipeRecv))

			#Cambiamos la ruta en la que esta el Software Arduino
			os.chdir('/home/pi/Domotics/Arduino')

			#Limpiamos el proyecto
			#os.system('sudo ino clean')

			#Compilamos
			os.system('sudo ino build -m leonardo')

			#Subimos el binario al ardino
			os.system('sudo ino upload -m leonardo')

			self.updateVersionDevice(idDevice)

			self.sendStatus()

			return 1

		else:

			self.numberOfPetitions += 1
			
			return -1

#################################################################################################################################################
#################################################################################################################################################
#####################################################       SECTION SECURITY CODE       #########################################################
#################################################################################################################################################
#################################################################################################################################################

	def updateSecurityCode(self):
		
		self.previousCode = self.currentCode
		self.currentCode = str(randint(10000,99999999))

		rpc_client = pyjsonrpc.HttpClient(url = deviceConfig.url)
		result = rpc_client("updateSecurityCode", deviceConfig.deviceId, self.currentCode, self.previousCode)
 
		while result == 0:

			time.sleep(5)
			result = rpc_client("updateSecurityCode", deviceConfig.deviceId, self.currentCode, self.previousCode)
			print "Intentamos enviar el codigo de seguridad"


		return result


#################################################################################################################################################
#################################################################################################################################################
################################################       SECTION GET DEVICE IP & PORT       #######################################################
#################################################################################################################################################
#################################################################################################################################################

	# private IP
	def getPrivateIp(self):

		success = False
		privateIp = 0

		while success == False:

			try:

				s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
				s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
				s.connect_ex(('<broadcast>', 0))

				privateIp = s.getsockname()[0]
			
				success = True

			except:

				success = False

				self.connectionStatus = 0
				self.leds.setLedsError()
				time.sleep(1)


		return privateIp
	
	# public IP
	def getPublicIp(self):

		success = False
		publicIp = 0
 
		while success == False:

			try:

				publicIp = json.load(urllib2.urlopen('http://httpbin.org/ip'))['origin']
				success = True

			except:

				self.connectionStatus = 0
				self.leds.setLedsError()
				time.sleep(1)

				try:

					publicIp = json.load(urllib2.urlopen('http://jsonip.com'))['ip']
					success = True

				except:

					self.connectionStatus = 0
					self.leds.setLedsError()
					time.sleep(1)

					try:

						publicIp = json.load(urllib2.urlopen('https://api.ipify.org/?format=json'))['ip']
						success = True

					except:

						success = False
						self.connectionStatus = 0
						self.leds.setLedsError()
						time.sleep(1)


		return publicIp


	# Port
	def getPort(self):

		success = False
		port = 0

		while success == False:

			try:
				rpc_client = pyjsonrpc.HttpClient(url = deviceConfig.url)
				port = rpc_client("getPort", deviceConfig.deviceId, self.currentCode)['port']
			
				success = True

			except:
				success = False

				self.connectionStatus = 0
				self.leds.setLedsError()
				time.sleep(1)

		return port


	def checkPortConnection(self, port, publicIp):

		# Setup socket
		sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
		sock.settimeout(1)

		connectionStatus = 2
		
		try:
			sock.connect((publicIp, port))
		
		except Exception,e:
			
			rpc_client = pyjsonrpc.HttpClient(url = deviceConfig.url)
			result = rpc_client("checkPort", publicIp, port)

			if result:
				#print "Port is open"
				connectionStatus = 1
   			
			else:
				#print "Port is not open"
				connectionStatus = 2
		
		else:
Exemplo n.º 35
0
 def modify_sounds(self):
     # load up sounds UI
     self.Sounds = Sounds(self)
     self.Sounds.show()
Exemplo n.º 36
0
class Game(object):
    TITLE = "Gold Rush!"
    WIDTH=680
    HEIGHT=600
    WAITING = 1
    PLAYING = 2
    FRAMES_PER_SECOND = 30

    board=[]

    def __init__(self):
        pygame.mixer.pre_init(44100,-16,2,2048)
        pygame.init()

        self.sounds=Sounds()


        self.input_handler = InputHandler()
        self.game_screen = GameScreen(self.TITLE,self.WIDTH,self.HEIGHT)
        self.miner=Miner(8,0)
        self.explosion=Explosion(-1,-1)
        self.game_screen.add_sprite(self.miner)
        self.game_screen.add_sprite(self.explosion)
        self.health = 100
         
        self.clock=pygame.time.Clock()
        self.state=self.WAITING
        self.game_screen.display_opening()

 
    def setup(self):
        self.gold=0
        self.charges=10
        self.cash=0
        self.health=100 
        self.board=[]
       
# top row of empty spaces
        self.board.append([' ']*20)
        self.board.append(['*']*20)
        for y in range(2,14):
            row=[]
            for x in range(20):
                c='*'
                if y>1 and random()<0.4:
                    c=' '
                    if random()<0.5:
                        c='0'
                    else:
                        c='1'
                row.append(c)
            self.board.append(row)
        self.miner.set_location(8,0)
        self.game_screen.setup()
        self.game_screen.set_board(self.board)
        self.game_screen.draw_board()



    def mainloop(self):
        deltat=self.clock.tick(self.FRAMES_PER_SECOND)
        running=True
        while running:
            self.input_handler.check()
            if self.input_handler.exit_action:
                running=False
            elif self.state == self.WAITING:
                if self.input_handler.key_press:
                    self.setup()
                    self.state=self.PLAYING
            else:
                self.game_screen.clear_sprites()
                if self.miner.can_move():
                    kpress=self.input_handler.arrow_press

                    if kpress:
                        dx=0
                        dy=0

                        if kpress == K_RIGHT:
                            dx=1
                        elif kpress == K_LEFT:
                            dx=-1
                        elif kpress == K_UP:
                            dy=-1
                        elif kpress == K_DOWN:
                            dy=1

                        if self.input_handler.space_press and (dx!=0 or dy!=0):
                            self.do_explosion(dx,dy)

                        tx=self.miner.x + dx
                        ty=self.miner.y + dy

                        if (dx!=0 or dy!=0) and (tx>=0 and tx<=19 and ty>=0 and ty<=13):
                            o=self.board[ty][tx]
                            if o in ' 01':
                                self.miner.set_location(tx,ty)
                                if o in '01':
                                    self.take_nugget(tx,ty)

                        elif (dy==-1 and tx==17 and ty==-1 and self.gold!=0):
                            self.cash_out()
                            if self.charges==0:
                                self.state=self.WAITING
                                self.input_handler.reset()
                                self.game_screen.display_gameover()



                    if self.miner.y>0:
                        self.health-=1
                        if self.health<0:
                            self.health=0
                        self.game_screen.display_health(self.health)
                    else:
                        self.health+=1
                        if self.health>100:
                            self.health=100
                        self.game_screen.display_health(self.health)
                

            self.game_screen.draw(deltat)
 
        pygame.quit()


    def do_explosion(self,dx,dy):
        bx=self.miner.x + dx
        by=self.miner.y + dy
        if bx>=0 and bx<20 and (by>0 or (by==0 and dy==1)) and by<14 and self.charges>0:

            self.explosion.explode(bx,by)

            self.charges-=1
            self.board[by][bx]=' '
            self.miner.add_delay(20)

            self.game_screen.clear_square(bx,by)
            self.game_screen.display_charges()
            self.sounds.play_boom()
            self.game_screen.display_charges(self.charges)

            for j in range(20):
                x=randint(0,19)
                y=randint(2,11)
                o=self.board[y][x]
                a=self.board[y-1][x]
                if o==' ' and a=='*':
                    self.board[y][x]='*'
                    self.game_screen.reset_square(x,y)

    def cash_out(self):
        self.cash+=self.gold*self.charges
        self.gold=0
        self.sounds.play_kaching()
        self.game_screen.display_gold(self.gold)
        self.game_screen.display_cash(self.cash)
        self.sounds.play_yeehaw()


    def take_nugget(self,tx,ty):
        self.board[ty][tx]=' '
        self.gold += 1
        self.sounds.play_bell()
        self.game_screen.clear_square(tx,ty)
        self.game_screen.display_gold(self.gold)
Exemplo n.º 37
0
def start_game():

    #needs to be called before pygame.init
    pygame.mixer.pre_init(22050, -16, 2, 1024)

    window = Window()
    window.init()

    pygame.init()

    sounds = Sounds()
    sounds.init()
    window.sounds = sounds
    pygame.mixer.set_num_channels(32)

    # meta game loop    
    while True:
        sounds.play_music("intro", loop=1)
        intro_main(window, handle_events)
        

        # so we can mix more channels at once.  pygame defaults to 8.
        #sounds.play("jump1")
        #sounds.play("hit1")
        #sounds.play("goal1")
        sounds.set_music_tracks(['track-one', 'track-two'])

        world = World()
        world.stage = 2
        populate(world, window)

        def count_leaves():
            no_leaves = 0
            for item in world.items:
                if item.role == "Bough":
                    no_leaves = no_leaves + 1
            return no_leaves
        
        CleanUp_Event = pygame.event.Event(CLEANUP, message="Cleaning Up Your shit")
        pygame.time.set_timer(CLEANUP, 1000)

        TickTock = pygame.event.Event(TICK_TOCK, message="TickTock goes the Ticking Clock")
        pygame.time.set_timer(TICK_TOCK, int(90000/count_leaves()))

        AddCherry = pygame.event.Event(ADDCHERRY, message="Ooooo Cherry")
        pygame.time.set_timer(ADDCHERRY, int(90000/5))
           
        AddOwange = pygame.event.Event(ADDOWANGE, message="Ooooo owange")
        pygame.time.set_timer(ADDOWANGE, int(1000 * 5))

        for i in range(3):
            event.post(AddOwange)        
           
        pygame.time.set_timer(BIRDY, 1000 * 7)



        render = Render(window, world)
        quit = runloop(window, world, render)
        if quit:
            return