示例#1
0
    def __init__(self, start_level, session_number, session_duration,
                 time_board_display, time_left_out, tagger, session_type,
                 session_condition):
        super(MazeLogic, self).__init__()
        self.start_level = start_level
        self.session_timer = SessionWatcher(session_duration, time_left_out)
        self.level = MazeLevel(session_type)
        self.number_of_levels = self.level.get_number_of_levels()
        self.screen = MazeScreen(time_board_display, self.number_of_levels,
                                 session_number, session_type,
                                 session_condition)
        self.status = True
        self.pause_status = False
        self.tagger = tagger
        self.session_number = session_number

        if session_condition in ['motor', 'key_motor']:
            self.path_check = True
        else:
            self.path_check = False
示例#2
0
    def __init__(self, start_level, session_number, session_duration, time_board_display,
                 time_left_out, tagger, session_type, session_condition):
        super(MazeLogic, self).__init__()
        self.start_level = start_level
        self.session_timer = SessionWatcher(session_duration, time_left_out)
        self.level = MazeLevel(session_type)
        self.number_of_levels = self.level.get_number_of_levels()
        self.screen = MazeScreen(time_board_display, self.number_of_levels, session_number, session_type, session_condition)
        self.status = True
        self.pause_status = False
        self.tagger = tagger
        self.session_number = session_number

        if session_condition in ['motor', 'key_motor']:
            self.path_check = True
        else:
            self.path_check = False
示例#3
0
class MazeLogic(object):
    def __init__(self, start_level, session_number, session_duration,
                 time_board_display, time_left_out, tagger, session_type,
                 session_condition):
        super(MazeLogic, self).__init__()
        self.start_level = start_level
        self.session_timer = SessionWatcher(session_duration, time_left_out)
        self.level = MazeLevel(session_type)
        self.number_of_levels = self.level.get_number_of_levels()
        self.screen = MazeScreen(time_board_display, self.number_of_levels,
                                 session_number, session_type,
                                 session_condition)
        self.status = True
        self.pause_status = False
        self.tagger = tagger
        self.session_number = session_number

        if session_condition in ['motor', 'key_motor']:
            self.path_check = True
        else:
            self.path_check = False

    def send_tag(self, timestamp, tag_name, tage_value=''):
        self.tagger.set_tag(timestamp, str(tag_name), str(tage_value))

    # def set_first_timestamp_to_tagger(self, timestamp):
    #     self.tagger.set_first_timestamp(timestamp)

    def save_tags(self):
        self.tagger.finish()

    def level_start(self):
        self.send_tag(time.time(), 'level_start', self.get_current_level())
        self.level_watcher = LevelWatcher(self.level.get_timeout_level())
        self.level_watcher.run()

    def level_finish(self):
        self.send_tag(time.time(), 'level_finish', self.get_current_level())

    def report_level_fail(self):
        self.level_watcher.report_level_fail()

    def get_level_fail(self):
        return self.level_watcher.get_level_fail()

    def can_level_repeat(self):
        return self.level_watcher.can_level_repeat()

    def get_level_status(self):
        return self.level_watcher.get_timer_status()

    def get_level_array(self):
        return self.level.get_level_array()

    def get_path_left(self):
        return self.level.get_path_left()

    def get_all_path(self):
        return self.level.get_all_path()

    def get_active_path(self):
        return self.level.get_active_path()

    def _clear_arrows(self):
        self.screen.arrow_right.set_level(0)
        self.screen.arrow_left.set_level(0)
        self.screen.arrow_down.set_level(0)
        self.screen.arrow_up.set_level(0)

    def load_level(self):
        self.level.load_level(self.get_current_level())
        self._clear_arrows()

    def get_current_level(self):
        return self.current_level

    def update_current_level(self):
        self.current_level += 1

    def set_current_level(self, level):
        if level:
            self.current_level = level

    def get_ball_position_x(self):
        return self.level.get_ball_x()

    def get_ball_position_y(self):
        return self.level.get_ball_y()

    def set_ball_position(self, x, y):
        self.level.set_ball_x(x)
        self.level.set_ball_y(y)

    def session_start(self):
        self.session_timer.run()
        # self.set_first_timestamp_to_tagger(self.session_timer.get_time_start())
        self.send_tag(self.session_timer.get_time_start(), 'session_start',
                      self.session_number)

    def session_finish(self):
        self.session_timer.stop()
        self.send_tag(self.session_timer.get_time_stop(), 'session_finish',
                      self.session_number)

    def get_session_status(self):
        return self.session_timer.get_timer_status()

    def get_session_length(self):
        return self.session_timer.get_time_length()

    def update_session_status(self):
        self.status = self.get_session_status()

    def get_level_time(self):
        return self.level_watcher.get_timer_time()

    def get_session_time(self):
        return self.session_timer.get_timer_time()

    def draw_game(self):
        self.screen.draw_game(self.get_level_array(),
                              self.get_ball_position_x(),
                              self.get_ball_position_y(),
                              self.get_current_level(), self.get_level_time(),
                              self.get_session_time(), self.get_all_path(),
                              self.get_active_path())

    def draw_game_with_arrow(self, arrow_type):
        self.screen.draw_game_with_arrow(arrow_type, self.get_level_array(),
                                         self.get_ball_position_x(),
                                         self.get_ball_position_y(),
                                         self.get_current_level(),
                                         self.get_level_time(),
                                         self.get_session_time(),
                                         self.get_all_path(),
                                         self.get_active_path())

    def draw_game_with_arrow_update(self, arrow_type, arrow_level):
        self.screen.draw_game_with_arrow_update(arrow_type, arrow_level,
                                                self.get_level_array(),
                                                self.get_ball_position_x(),
                                                self.get_ball_position_y(),
                                                self.get_current_level(),
                                                self.get_level_time(),
                                                self.get_session_time(),
                                                self.get_all_path(),
                                                self.get_active_path())

    def update_screen(self):
        self.draw_game()
        for event in pygame.event.get():
            if event.type == QUIT:
                self.exit_game()
            elif event.type == KEYDOWN:
                if event.key == K_ESCAPE:
                    self.exit_game()
                elif event.key in GAME_KEYS.keys():
                    self.draw_game_with_arrow(GAME_KEYS[event.key])
                    done = self.arrow_fill(GAME_KEYS[event.key])
                    if done:
                        self.send_tag(time.time(), 'move',
                                      GAME_KEYS[event.key])
                        self.move(GAME_KEYS[event.key])

                elif event.key == K_p:
                    self.make_pause()

    def arrow_fill(self, type_):
        time_start = time.time()

        arrow = self.screen.get_arrow(type_)
        key = ARROW_KEY[type_]

        level = arrow.get_level()
        if sum(pygame.key.get_pressed()) and pygame.key.name(
                pygame.key.get_pressed().index(1)) == type_:
            while level <= ARROW_SIZE:
                self.draw_game_with_arrow_update(type_, level)
                for event in pygame.event.get():
                    if event.type == KEYUP:
                        arrow.set_level(level)
                        self.arrow_wane(type_)
                        return False
                level += ARROW_SPEED_UP * 1.0 / FRAME_RATE
                time.sleep(1.0 / FRAME_RATE)

            arrow.set_level(0)
            return True
        else:
            arrow.set_level(0)
            return False

    def arrow_wane(self, type_):
        time_start = time.time()

        arrow = self.screen.get_arrow(type_)
        key = ARROW_KEY[type_]

        level = arrow.get_level()
        while level > 0:
            self.draw_game_with_arrow_update(type_, level)
            for event in pygame.event.get():
                if event.type == KEYDOWN:
                    pygame.event.post(event)
                    if event.key == key:
                        arrow.set_level(level)
                    else:
                        arrow.set_level(0)
                    return
            level -= ARROW_SPEED_DOWN * 1.0 / FRAME_RATE
            time.sleep(1.0 / FRAME_RATE)
        arrow.set_level(0)

    def move(self, type_):
        if type_ == 'left':
            self._move(
                x_update=-1,
                x_animation_offset_update=-float(self.screen.size_object) / 4)

        elif type_ == 'right':
            self._move(
                x_update=1,
                x_animation_offset_update=float(self.screen.size_object) / 4)

        elif type_ == 'down':
            self._move(
                y_update=1,
                y_animation_offset_update=float(self.screen.size_object) / 4)

        elif type_ == 'up':
            self._move(
                y_update=-1,
                y_animation_offset_update=-float(self.screen.size_object) / 4)

        if self.path_check:
            if self.get_path_left():
                pass
            else:
                self.repeat_level()

    def _move(self,
              x_update=0,
              y_update=0,
              y_animation_offset_update=0,
              x_animation_offset_update=0,
              number=0):
        self.screen.set_animation_offset_x(0)
        self.screen.set_animation_offset_y(0)
        x_position, y_position = self.get_ball_position_x(
        ), self.get_ball_position_y()
        x_new, y_new = x_position + x_update, y_position + y_update
        if self.get_level_array()[y_new][x_new] == 2:
            self.set_ball_position(x_new, y_new)
            self.draw_game()
            self.repeat_level()

        elif self.get_level_array()[y_new][x_new] == 1:
            self.draw_game()
            self.hit_wall()
            if (not number) and self.path_check:
                self.repeat_level()

        elif self.get_level_array()[y_new][x_new] in [0, 3]:
            for i in range(4):
                self.screen.update_animation_offset_y(
                    y_animation_offset_update)
                self.screen.update_animation_offset_x(
                    x_animation_offset_update)
                self.draw_game()
                time.sleep(0.025)
            self.set_ball_position(x_new, y_new)
            self._move(x_update,
                       y_update,
                       y_animation_offset_update,
                       x_animation_offset_update,
                       number=number + 1)

        elif self.get_level_array()[y_new][x_new] == 4:
            self.set_ball_position(x_new, y_new)
            self.draw_game()
            self.win_level()

    def make_pause(self):
        self.send_tag(time.time(), 'pause', 'start')
        self.session_timer.make_pause()
        self.level_watcher.make_pause()
        self.pause_status = True
        self.screen.display_screen('pause')
        while self.pause_status:
            for event in pygame.event.get():
                if event.type == QUIT:
                    self.finish_game()
                elif event.type == KEYDOWN:
                    if event.key == K_ESCAPE:
                        self.finish_game()
                    if event.key == K_p:
                        self.pause_status = False

        self.session_timer.finish_pause()
        self.level_watcher.finish_pause()
        self.send_tag(time.time(), 'pause', 'stop')
        self.update_session_status()
        if self.status:
            self.load_level()

    def repeat_level(self):
        self.send_tag(time.time(), 'repeat_level', self.get_level_fail())
        self.report_level_fail()
        self.screen.play_sound('fall')
        time.sleep(1.0)
        self.update_session_status()
        if self.can_level_repeat():
            if self.get_level_fail() == 1:
                self.screen.display_screen('repeat_level_1')
            elif self.get_level_fail() == 2:
                self.screen.display_screen('repeat_level_2')
        else:
            self.level_finish()
            self.screen.display_screen('level_down')
            self.set_current_level(self.get_current_level() - 1)

        if self.status:
            if not self.can_level_repeat():
                self.level_start()
            self.load_level()

    def level_timeout(self):
        self.send_tag(time.time(), 'level_timeout')
        self.level_finish()
        self.update_session_status()
        self.set_current_level(self.get_current_level() - 1)
        self.screen.display_screen('level_timeout')
        if self.status:
            self.level_start()
            self.load_level()

    def win_level(self):
        self.send_tag(time.time(), 'win')
        self.level_finish()
        self.screen.play_sound('win')
        time.sleep(1.0)
        self.update_current_level()
        self.update_session_status()
        self.screen.display_screen('win')
        if self.get_current_level() <= self.number_of_levels and self.status:
            self.load_level()
            self.level_start()

    def hit_wall(self):
        self.screen.play_sound('hit_wall')

    def finish_game(self):
        self.screen.display_screen('finish')
        self.send_tag(time.time(), 'FINISH_exit')
        self.session_finish()
        self.save_tags()
        pygame.quit()

    def exit_game(self):
        self.send_tag(time.time(), 'ESC_exit')
        self.session_timer.make_pause()
        self.level_watcher.make_pause()
        self.pause_status = True
        self.screen.display_screen('exit')
        while self.pause_status:
            for event in pygame.event.get():
                if event.type == KEYDOWN:
                    if event.key == K_t:
                        self.status = False
                        return ''
                    if event.key == K_n:
                        self.pause_status = False
        self.session_timer.finish_pause()
        self.level_watcher.finish_pause()

        self.update_session_status()
        if self.status:
            self.load_level()

    def instruction(self):
        screens = ['start', 'instruction1', 'instruction2']
        screen_status = 0
        self.screen.display_screen(screens[screen_status])

        while screen_status < 3:
            for event in pygame.event.get():
                if event.type == KEYDOWN:
                    if event.key == K_SPACE:
                        screen_status += 1
                        if screen_status < len(screens):
                            self.screen.display_screen(screens[screen_status])

    def main(self):
        self.set_current_level(self.start_level)
        self.load_level()
        self.instruction()
        self.session_start()
        self.level_start()
        while self.get_current_level(
        ) <= self.number_of_levels and self.status:
            if not self.get_level_status():
                self.level_timeout()
            else:
                self.update_screen()
            time.sleep(1 / FRAME_RATE)
        self.finish_game()
示例#4
0
class MazeLogic(object):

    def __init__(self, start_level, session_number, session_duration, time_board_display,
                 time_left_out, tagger, session_type, session_condition):
        super(MazeLogic, self).__init__()
        self.start_level = start_level
        self.session_timer = SessionWatcher(session_duration, time_left_out)
        self.level = MazeLevel(session_type)
        self.number_of_levels = self.level.get_number_of_levels()
        self.screen = MazeScreen(time_board_display, self.number_of_levels, session_number, session_type, session_condition)
        self.status = True
        self.pause_status = False
        self.tagger = tagger
        self.session_number = session_number

        if session_condition in ['motor', 'key_motor']:
            self.path_check = True
        else:
            self.path_check = False

    def send_tag(self, timestamp, tag_name, tage_value=''):
        self.tagger.set_tag(timestamp, str(tag_name), str(tage_value))

    # def set_first_timestamp_to_tagger(self, timestamp):
    #     self.tagger.set_first_timestamp(timestamp)

    def save_tags(self):
        self.tagger.finish()

    def level_start(self):
        self.send_tag(time.time(), 'level_start', self.get_current_level())
        self.level_watcher = LevelWatcher(self.level.get_timeout_level())
        self.level_watcher.run()

    def level_finish(self):
        self.send_tag(time.time(), 'level_finish', self.get_current_level())

    def report_level_fail(self):
        self.level_watcher.report_level_fail()

    def get_level_fail(self):
        return self.level_watcher.get_level_fail()

    def can_level_repeat(self):
        return self.level_watcher.can_level_repeat()

    def get_level_status(self):
        return self.level_watcher.get_timer_status()

    def get_level_array(self):
        return self.level.get_level_array()

    def get_path_left(self):
        return self.level.get_path_left()

    def get_all_path(self):
        return self.level.get_all_path()

    def get_active_path(self):
        return self.level.get_active_path()

    def _clear_arrows(self):
        self.screen.arrow_right.set_level(0)
        self.screen.arrow_left.set_level(0)
        self.screen.arrow_down.set_level(0)
        self.screen.arrow_up.set_level(0)

    def load_level(self):
        self.level.load_level(self.get_current_level())
        self._clear_arrows()

    def get_current_level(self):
        return self.current_level

    def update_current_level(self):
        self.current_level+=1

    def set_current_level(self, level):
        if level:
            self.current_level=level

    def get_ball_position_x(self):
        return self.level.get_ball_x()

    def get_ball_position_y(self):
        return self.level.get_ball_y()

    def set_ball_position(self, x, y):
        self.level.set_ball_x(x)
        self.level.set_ball_y(y)

    def session_start(self):
        self.session_timer.run()
        # self.set_first_timestamp_to_tagger(self.session_timer.get_time_start())
        self.send_tag(self.session_timer.get_time_start(),'session_start', self.session_number)

    def session_finish(self):
        self.session_timer.stop()
        self.send_tag(self.session_timer.get_time_stop(), 'session_finish', self.session_number)

    def get_session_status(self):
        return self.session_timer.get_timer_status()

    def get_session_length(self):
        return self.session_timer.get_time_length()

    def update_session_status(self):
        self.status = self.get_session_status()

    def get_level_time(self):
        return self.level_watcher.get_timer_time()

    def get_session_time(self):
        return self.session_timer.get_timer_time()

    def draw_game(self):
        self.screen.draw_game(self.get_level_array(),
                             self.get_ball_position_x(),
                             self.get_ball_position_y(),
                             self.get_current_level(),
                             self.get_level_time(),
                             self.get_session_time(),
                             self.get_all_path(),
                             self.get_active_path())

    def draw_game_with_arrow(self, arrow_type):
        self.screen.draw_game_with_arrow(arrow_type,
                                         self.get_level_array(),
                                         self.get_ball_position_x(),
                                         self.get_ball_position_y(),
                                         self.get_current_level(),
                                         self.get_level_time(),
                                         self.get_session_time(),
                                         self.get_all_path(),
                                         self.get_active_path())        

    def draw_game_with_arrow_update(self, arrow_type, arrow_level):
        self.screen.draw_game_with_arrow_update(arrow_type,
                                               arrow_level,
                                               self.get_level_array(),
                                               self.get_ball_position_x(),
                                               self.get_ball_position_y(),
                                               self.get_current_level(),
                                               self.get_level_time(),
                                               self.get_session_time(),
                                               self.get_all_path(),
                                               self.get_active_path())
                                                                    
    def update_screen(self):
        self.draw_game()
        for event in pygame.event.get():                    
            if event.type == QUIT:
                self.exit_game()
            elif event.type == KEYDOWN:           
                if event.key == K_ESCAPE:
                    self.exit_game()
                elif event.key in GAME_KEYS.keys():
                    self.draw_game_with_arrow(GAME_KEYS[event.key])
                    done = self.arrow_fill(GAME_KEYS[event.key])
                    if done:
                        self.send_tag(time.time(), 'move', GAME_KEYS[event.key])
                        self.move(GAME_KEYS[event.key])

                elif event.key == K_p:
                    self.make_pause()

    def arrow_fill(self, type_):
        time_start = time.time()

        arrow = self.screen.get_arrow(type_)
        key = ARROW_KEY[type_]

        level = arrow.get_level()
        if sum(pygame.key.get_pressed()) and pygame.key.name(pygame.key.get_pressed().index(1))==type_:
            while level <= ARROW_SIZE:
                self.draw_game_with_arrow_update(type_,level)
                for event in pygame.event.get():
                    if event.type == KEYUP:
                        arrow.set_level(level)
                        self.arrow_wane(type_)
                        return False
                level += ARROW_SPEED_UP*1.0/FRAME_RATE
                time.sleep(1.0/FRAME_RATE)

            arrow.set_level(0)
            return True
        else:
            arrow.set_level(0)
            return False

    def arrow_wane(self, type_):
        time_start = time.time()
        
        arrow = self.screen.get_arrow(type_)
        key = ARROW_KEY[type_]

        level = arrow.get_level()
        while level > 0:
            self.draw_game_with_arrow_update(type_, level)
            for event in pygame.event.get():
                if event.type == KEYDOWN:
                    pygame.event.post(event)
                    if event.key == key:
                        arrow.set_level(level)
                    else:
                        arrow.set_level(0)
                    return
            level -= ARROW_SPEED_DOWN*1.0/FRAME_RATE
            time.sleep(1.0/FRAME_RATE)
        arrow.set_level(0)

    def move(self, type_):
        if type_=='left':
            self._move(x_update=-1, x_animation_offset_update=-float(self.screen.size_object)/4)

        elif type_=='right':
            self._move(x_update=1, x_animation_offset_update=float(self.screen.size_object)/4)

        elif type_=='down':
            self._move(y_update=1, y_animation_offset_update=float(self.screen.size_object)/4)

        elif type_=='up':
            self._move(y_update=-1, y_animation_offset_update=-float(self.screen.size_object)/4)

        if self.path_check:
            if self.get_path_left():
                pass
            else:
                self.repeat_level()              

    def _move(self, x_update=0, y_update=0, y_animation_offset_update=0, x_animation_offset_update=0, number=0):
        self.screen.set_animation_offset_x(0)
        self.screen.set_animation_offset_y(0)
        x_position, y_position = self.get_ball_position_x(), self.get_ball_position_y()
        x_new, y_new = x_position+x_update, y_position+y_update
        if self.get_level_array()[y_new][x_new] == 2:
            self.set_ball_position(x_new, y_new)
            self.draw_game()
            self.repeat_level()

        elif self.get_level_array()[y_new][x_new] == 1: 
            self.draw_game()
            self.hit_wall()
            if (not number) and self.path_check:
                self.repeat_level()

        elif self.get_level_array()[y_new][x_new] in [0, 3]:
            for i in range(4):
                self.screen.update_animation_offset_y(y_animation_offset_update)
                self.screen.update_animation_offset_x(x_animation_offset_update)
                self.draw_game()
                time.sleep(0.025)
            self.set_ball_position(x_new, y_new)
            self._move(x_update, y_update, y_animation_offset_update, x_animation_offset_update, number=number+1)

        elif self.get_level_array()[y_new][x_new] == 4:
            self.set_ball_position(x_new, y_new)
            self.draw_game()
            self.win_level()

    def make_pause(self):
        self.send_tag(time.time(), 'pause', 'start')
        self.session_timer.make_pause()
        self.level_watcher.make_pause()
        self.pause_status=True
        self.screen.display_screen('pause')
        while self.pause_status:
            for event in pygame.event.get():                    
                if event.type == QUIT:
                    self.finish_game()
                elif event.type == KEYDOWN:            
                    if event.key == K_ESCAPE:
                        self.finish_game()
                    if event.key == K_p:
                        self.pause_status = False

        self.session_timer.finish_pause()
        self.level_watcher.finish_pause()
        self.send_tag(time.time(), 'pause', 'stop')
        self.update_session_status()
        if self.status:
            self.load_level()

    def repeat_level(self):
        self.send_tag(time.time(), 'repeat_level', self.get_level_fail())
        self.report_level_fail()
        self.screen.play_sound('fall')
        time.sleep(1.0)
        self.update_session_status()
        if self.can_level_repeat():
            if self.get_level_fail() == 1:
                self.screen.display_screen('repeat_level_1')
            elif self.get_level_fail() == 2:
                self.screen.display_screen('repeat_level_2')
        else:
            self.level_finish()
            self.screen.display_screen('level_down')
            self.set_current_level(self.get_current_level()-1)

        if self.status:
            if not self.can_level_repeat():
                self.level_start()
            self.load_level()

    def level_timeout(self):
        self.send_tag(time.time(), 'level_timeout')
        self.level_finish()
        self.update_session_status() 
        self.set_current_level(self.get_current_level()-1)
        self.screen.display_screen('level_timeout')
        if self.status:
            self.level_start()
            self.load_level() 

    def win_level(self):
        self.send_tag(time.time(), 'win')
        self.level_finish()
        self.screen.play_sound('win')
        time.sleep(1.0)
        self.update_current_level()
        self.update_session_status()
        self.screen.display_screen('win')
        if self.get_current_level()<=self.number_of_levels and self.status:
            self.load_level()
            self.level_start()

    def hit_wall(self):
        self.screen.play_sound('hit_wall')

    def finish_game(self):
        self.screen.display_screen('finish')
        self.send_tag(time.time(), 'FINISH_exit')
        self.session_finish()
        self.save_tags()
        pygame.quit()

    def exit_game(self):
        self.send_tag(time.time(), 'ESC_exit')
        self.session_timer.make_pause()
        self.level_watcher.make_pause()
        self.pause_status=True
        self.screen.display_screen('exit')
        while self.pause_status:
            for event in pygame.event.get():                    
                if event.type == KEYDOWN:            
                    if event.key == K_t:
                        self.status = False
                        return ''
                    if event.key == K_n:
                        self.pause_status = False
        self.session_timer.finish_pause()
        self.level_watcher.finish_pause()

        self.update_session_status()
        if self.status:
            self.load_level()

    def instruction(self):
        screens = ['start', 'instruction1', 'instruction2']
        screen_status = 0
        self.screen.display_screen(screens[screen_status])

        while screen_status<3:
            for event in pygame.event.get():                    
                if event.type == KEYDOWN:            
                    if event.key == K_SPACE:
                        screen_status+=1 
                        if screen_status<len(screens):
                            self.screen.display_screen(screens[screen_status])

    def main(self):    
        self.set_current_level(self.start_level)
        self.load_level()  
        self.instruction()
        self.session_start() 
        self.level_start()
        while self.get_current_level()<= self.number_of_levels and self.status:
            if not self.get_level_status():
                self.level_timeout()
            else:
                self.update_screen()
            time.sleep(1/FRAME_RATE)
        self.finish_game()