game_qu.gui_components.intermediate_screen API documentation

# Module `game_qu.gui_components.intermediate_screen`

Expand source code

    from game_qu.base.colors import white
    from game_qu.base.utility_functions import get_index_of_range, get_ranges
    from game_qu.gui_components.dimensions import Dimensions
    from game_qu.base.events import TimedEvent
    from game_qu.base.important_variables import BACKGROUND_COLOR, SCREEN_LENGTH, SCREEN_HEIGHT
    from game_qu.gui_components.screen import Screen
    from game_qu.gui_components.text_box import TextBox

    from game_qu.base.range import Range
    from game_qu.base.velocity_calculator import VelocityCalculator

    class IntermediateScreen(Screen):
        """A screen that displays text(s) for a period of time"""

        time_ranges = []
        current_time = 0
        max_time = 0
        screens = []
        texts = []
        set_screen_text_function = None
        is_being_displayed = False

        def __init__(self, number_of_screens=1, screens=None, texts=[""], times_displayed=[0], set_screen_text_function=None):
            """Initializes the object"""

            if screens is None:
                self.create_screens(number_of_screens, texts)

            else:
                self.screens = screens

            self.set_time_ranges(get_ranges(times_displayed))

            self.set_screen_text_function = self.set_screen_text if set_screen_text_function is None else set_screen_text_function

            Dimensions.__init__(self, 0, 0, SCREEN_LENGTH, SCREEN_HEIGHT)

        def create_screens(self, number_of_screens, texts):
            """Initializes all the screens (equal to the number_of_screens)"""

            for x in range(number_of_screens):
                screen = Screen()

                text_box = TextBox(texts[x], 30, BACKGROUND_COLOR, white, True)
                text_box.number_set_dimensions(0, 0, SCREEN_LENGTH, SCREEN_HEIGHT)
                screen.components = [text_box]
                self.screens.append(screen)

        def set_texts(self, texts):
            """Sets the texts of all the screens in 'self.screens.' It does this by using the method 'self.change_screen_method,' which is set in the __init__ method"""

            for x in range(len(texts)):
                self.set_screen_text_function(self.screens[x], texts[x])

        def set_screen_text(self, screen, text):
            """Sets the text the screen displays (or no text if that is wanted). Calls the 'set_text' method of the screen's first component"""

            # By default, the screen's first component is the TextBox containing the text
            screen.components[0].set_text(text)

        def display(self):
            """Displays all the intermediate screens and sets 'self.current_time' to 0 resetting the screen timers"""

            self.current_time = 0
            self.is_being_displayed = True

        def get_components(self):
            """
                 Returns:
                    list[Component]: the components that should be displayed"""

            index = get_index_of_range(self.current_time, ranges=self.time_ranges)
            self.screens[index].render_background()
            return self.screens[index].get_components()

        def reset(self):
            """Resets the object back to the start"""

            self.current_time = 0
            self.is_being_displayed = False

        def set_time_ranges(self, time_ranges):
            """ Sets the time ranges that each screen is displayed (from 1 second to 3 seconds). If using range_lengths is wanted then
                it is recommended to use the function get_ranges in base/utility_functions.py"""

            self.time_ranges = time_ranges
            self.max_time = 0

            for time_range in time_ranges:
                self.max_time += time_range.get_length()

        def has_finished(self):
            """
                 Returns:
                    bool: if the intermediate screens are done being displayed"""

            return self.current_time > self.max_time or not self.is_being_displayed

        def run(self):
            """Runs all the code necessary to make this object work properly"""

            if not self.has_finished():
                self.current_time += VelocityCalculator.time
                index = get_index_of_range(self.current_time, ranges=self.time_ranges)
                self.screens[index].run()

## Classes

`class IntermediateScreen (number_of_screens=1, screens=None, texts=[''], times_displayed=[0], set_screen_text_function=None)`

  A screen that displays text(s) for a period of time

  Initializes the object

  Expand source code

      class IntermediateScreen(Screen):
          """A screen that displays text(s) for a period of time"""

          time_ranges = []
          current_time = 0
          max_time = 0
          screens = []
          texts = []
          set_screen_text_function = None
          is_being_displayed = False

          def __init__(self, number_of_screens=1, screens=None, texts=[""], times_displayed=[0], set_screen_text_function=None):
              """Initializes the object"""

              if screens is None:
                  self.create_screens(number_of_screens, texts)

              else:
                  self.screens = screens

              self.set_time_ranges(get_ranges(times_displayed))

              self.set_screen_text_function = self.set_screen_text if set_screen_text_function is None else set_screen_text_function

              Dimensions.__init__(self, 0, 0, SCREEN_LENGTH, SCREEN_HEIGHT)

          def create_screens(self, number_of_screens, texts):
              """Initializes all the screens (equal to the number_of_screens)"""

              for x in range(number_of_screens):
                  screen = Screen()

                  text_box = TextBox(texts[x], 30, BACKGROUND_COLOR, white, True)
                  text_box.number_set_dimensions(0, 0, SCREEN_LENGTH, SCREEN_HEIGHT)
                  screen.components = [text_box]
                  self.screens.append(screen)

          def set_texts(self, texts):
              """Sets the texts of all the screens in 'self.screens.' It does this by using the method 'self.change_screen_method,' which is set in the __init__ method"""

              for x in range(len(texts)):
                  self.set_screen_text_function(self.screens[x], texts[x])

          def set_screen_text(self, screen, text):
              """Sets the text the screen displays (or no text if that is wanted). Calls the 'set_text' method of the screen's first component"""

              # By default, the screen's first component is the TextBox containing the text
              screen.components[0].set_text(text)

          def display(self):
              """Displays all the intermediate screens and sets 'self.current_time' to 0 resetting the screen timers"""

              self.current_time = 0
              self.is_being_displayed = True

          def get_components(self):
              """
                   Returns:
                      list[Component]: the components that should be displayed"""

              index = get_index_of_range(self.current_time, ranges=self.time_ranges)
              self.screens[index].render_background()
              return self.screens[index].get_components()

          def reset(self):
              """Resets the object back to the start"""

              self.current_time = 0
              self.is_being_displayed = False

          def set_time_ranges(self, time_ranges):
              """ Sets the time ranges that each screen is displayed (from 1 second to 3 seconds). If using range_lengths is wanted then
                  it is recommended to use the function get_ranges in base/utility_functions.py"""

              self.time_ranges = time_ranges
              self.max_time = 0

              for time_range in time_ranges:
                  self.max_time += time_range.get_length()

          def has_finished(self):
              """
                   Returns:
                      bool: if the intermediate screens are done being displayed"""

              return self.current_time > self.max_time or not self.is_being_displayed

          def run(self):
              """Runs all the code necessary to make this object work properly"""

              if not self.has_finished():
                  self.current_time += VelocityCalculator.time
                  index = get_index_of_range(self.current_time, ranges=self.time_ranges)
                  self.screens[index].run()

  ### Ancestors

  - Screen
  - Component
  - Dimensions

  ### Class variables

  `var current_time`
  `var is_being_displayed`
  `var max_time`
  `var screens`
  `var set_screen_text_function`
  `var texts`
  `var time_ranges`

  ### Methods

  `def create_screens(self, number_of_screens, texts)`

    Initializes all the screens (equal to the number_of_screens)

    Expand source code

        def create_screens(self, number_of_screens, texts):
            """Initializes all the screens (equal to the number_of_screens)"""

            for x in range(number_of_screens):
                screen = Screen()

                text_box = TextBox(texts[x], 30, BACKGROUND_COLOR, white, True)
                text_box.number_set_dimensions(0, 0, SCREEN_LENGTH, SCREEN_HEIGHT)
                screen.components = [text_box]
                self.screens.append(screen)

  `def display(self)`

    Displays all the intermediate screens and sets 'self.current_time' to 0 resetting the screen timers

    Expand source code

        def display(self):
            """Displays all the intermediate screens and sets 'self.current_time' to 0 resetting the screen timers"""

            self.current_time = 0
            self.is_being_displayed = True

  `def get_components(self)`

    ## Returns

    `list[Component]`
      the components that should be displayed
    Expand source code

        def get_components(self):
            """
                 Returns:
                    list[Component]: the components that should be displayed"""

            index = get_index_of_range(self.current_time, ranges=self.time_ranges)
            self.screens[index].render_background()
            return self.screens[index].get_components()

  `def has_finished(self)`

    ## Returns

    `bool`
      if the intermediate screens are done being displayed
    Expand source code

        def has_finished(self):
            """
                 Returns:
                    bool: if the intermediate screens are done being displayed"""

            return self.current_time > self.max_time or not self.is_being_displayed

  `def reset(self)`

    Resets the object back to the start

    Expand source code

        def reset(self):
            """Resets the object back to the start"""

            self.current_time = 0
            self.is_being_displayed = False

  `def run(self)`

    Runs all the code necessary to make this object work properly

    Expand source code

        def run(self):
            """Runs all the code necessary to make this object work properly"""

            if not self.has_finished():
                self.current_time += VelocityCalculator.time
                index = get_index_of_range(self.current_time, ranges=self.time_ranges)
                self.screens[index].run()

  `def set_screen_text(self, screen, text)`

    Sets the text the screen displays (or no text if that is wanted). Calls the 'set_text' method of the screen's first component

    Expand source code

        def set_screen_text(self, screen, text):
            """Sets the text the screen displays (or no text if that is wanted). Calls the 'set_text' method of the screen's first component"""

            # By default, the screen's first component is the TextBox containing the text
            screen.components[0].set_text(text)

  `def set_texts(self, texts)`

    Sets the texts of all the screens in 'self.screens.' It does this by using the method 'self.change_screen_method,' which is set in the init method

    Expand source code

        def set_texts(self, texts):
            """Sets the texts of all the screens in 'self.screens.' It does this by using the method 'self.change_screen_method,' which is set in the __init__ method"""

            for x in range(len(texts)):
                self.set_screen_text_function(self.screens[x], texts[x])

  `def set_time_ranges(self, time_ranges)`

    Sets the time ranges that each screen is displayed (from 1 second to 3 seconds). If using range_lengths is wanted then it is recommended to use the function get_ranges in base/utility_functions.py

    Expand source code

        def set_time_ranges(self, time_ranges):
            """ Sets the time ranges that each screen is displayed (from 1 second to 3 seconds). If using range_lengths is wanted then
                it is recommended to use the function get_ranges in base/utility_functions.py"""

            self.time_ranges = time_ranges
            self.max_time = 0

            for time_range in time_ranges:
                self.max_time += time_range.get_length()

  ### Inherited members

  - `Screen`:
    - `bottom_edge`
    - `get_scaled_dimensions`
    - `got_clicked`
    - `hide`
    - `horizontal_midpoint`
    - `mouse_enter_function`
    - `mouse_exit_function`
    - `number_set_dimensions`
    - `percentage_set_dimensions`
    - `render`
    - `render_background`
    - `right_edge`
    - `set_background_color`
    - `set_color`
    - `set_is_visible`
    - `set_mouse_enter_function`
    - `set_mouse_exit_function`
    - `set_mouse_functions`
    - `set_path_to_background_image`
    - `show`
    - `vertical_midpoint`