game_qu.paths.physics_followable_path API documentation

# Module `game_qu.paths.physics_followable_path`

Expand source code

    from game_qu.base.utility_functions import get_kwarg_item
    from game_qu.base.velocity_calculator import VelocityCalculator
    from game_qu.math.physics_function import PhysicsFunction
    from game_qu.paths.followable_path import FollowablePath

    class PhysicsFollowablePath(FollowablePath, PhysicsFunction):
        """ An extension of physics function that allows for automatically changing the player's coordinates; implements
            the FollowablePath 'interface'"""

        game_object = None
        current_time = 0
        is_started = False
        attribute_modifying = None
        height_of_path = 0
        time = 0
        max_time = 0
        last_time = 0
        has_max_time = False
        all_distance = 0
        last_delta_time = 0
        is_using_everything_this_cycle = False

        # def __init__(self, game_object=None, attribute_modifying="", height_of_path=0, initial_distance=0, time=.5):
        def __init__(self, **kwargs):
            """ Initializes the object

                Args:
                    game_object (GameObject): the game object that is following this path
                    attribute_modifying (str): the name of the attribute this path is modifying
                    time (float): the time to the vertex of the path
                    height_of_path (float): the difference between the initial distance and the vertex of the path
                    max_time (float): the max time of the path - the time the path should end (None if the path should not end)

                Returns:
                    None
            """

            FollowablePath.__init__(self, **kwargs)
            self.time, self.height_of_path = get_kwarg_item(kwargs, "time", .5), get_kwarg_item(kwargs, "height_of_path", 0)
            self.initial_distance = get_kwarg_item(kwargs, "initial_distance", 0)

            # Adding the initial_distance, so it that is the height of the parabola
            self.set_all_variables(self.height_of_path + self.initial_distance, self.time, self.initial_distance)

        def run(self, is_reset_event, is_start_event, is_using_everything=False, is_changing_coordinates=True):
            """ Runs the code for the game_object following the physics path

                Args:
                    is_reset_event (bool): if True it will call reset()
                    is_start_event (bool): if True it will call start()
                    is_using_everything (bool): if True it will use both velocity and acceleration and if False will just use velocity

                Returns:
                    None
            """

            self.is_using_everything_this_cycle = is_using_everything

            # Calling the super method, but being explicit about which one I am looking for
            PhysicsFollowablePath.run(self, is_reset_event, is_start_event, is_changing_coordinates)

        def set_initial_distance(self, initial_distance):
            """Sets the initial distance, so the height of the parabola is equal to the vertex"""

            self.initial_distance = initial_distance
            self.set_all_variables(self.initial_distance + self.height_of_path, self.time, self.initial_distance)

        def get_velocity_displacement(self):
            """
                 Returns:
                    float: the displacement from velocity (the last_time - start_time)"""

            return self.get_displacement_due_to_velocity(self.last_time, self.current_time)

        def get_acceleration_displacement(self):
            """
                 Returns:
                    float: the distance from acceleration with gravity"""

            return self.get_displacement_due_to_acceleration(self.last_time, self.current_time)

        def get_total_displacement(self):
            """
                 Returns:
                    float: the displacement from both velocity and acceleration"""

            return self.get_velocity_displacement() + self.get_acceleration_displacement()

        def get_acceleration_displacement_from_time(self, time):
            """
                 Returns:
                    float: the displacement from acceleration at that time"""

            return self.get_displacement_due_to_acceleration(0, time)

        def get_final_velocity(self):
            """
                 Returns:
                    float: the velocity from acceleration (assumes initial_velocity is 0)"""

            return self.acceleration * self.current_time

        def get_value_at_time(self, time):
            """
                 Returns:
                    object: the value of the attribute this path is modifying at 'time'"""

            if self.is_using_everything_this_cycle:
                self.get_distance(time)

            else:
                return self.get_displacement_due_to_velocity(0, time)

        def get_delta_value(self, start_time, end_time):
            """
                 Returns:
                    object: the delta value of the attribute within the domain [start_time, end_time]"""

            if self.is_using_everything_this_cycle:
                self.get_distance(end_time)

            else:
                return self.get_displacement_due_to_velocity(start_time, end_time)

## Classes

`class PhysicsFollowablePath (**kwargs)`

  An extension of physics function that allows for automatically changing the player's coordinates; implements the FollowablePath 'interface'

  Initializes the object

  ## Args

  `game_object` :`GameObject`
    the game object that is following this path
  `attribute_modifying` :`str`
    the name of the attribute this path is modifying
  `time` :`float`
    the time to the vertex of the path
  `height_of_path` :`float`
    the difference between the initial distance and the vertex of the path
  `max_time` :`float`
    the max time of the path - the time the path should end (None if the path should not end)

  ## Returns

  None

  Expand source code

      class PhysicsFollowablePath(FollowablePath, PhysicsFunction):
          """ An extension of physics function that allows for automatically changing the player's coordinates; implements
              the FollowablePath 'interface'"""

          game_object = None
          current_time = 0
          is_started = False
          attribute_modifying = None
          height_of_path = 0
          time = 0
          max_time = 0
          last_time = 0
          has_max_time = False
          all_distance = 0
          last_delta_time = 0
          is_using_everything_this_cycle = False

          # def __init__(self, game_object=None, attribute_modifying="", height_of_path=0, initial_distance=0, time=.5):
          def __init__(self, **kwargs):
              """ Initializes the object

                  Args:
                      game_object (GameObject): the game object that is following this path
                      attribute_modifying (str): the name of the attribute this path is modifying
                      time (float): the time to the vertex of the path
                      height_of_path (float): the difference between the initial distance and the vertex of the path
                      max_time (float): the max time of the path - the time the path should end (None if the path should not end)

                  Returns:
                      None
              """

              FollowablePath.__init__(self, **kwargs)
              self.time, self.height_of_path = get_kwarg_item(kwargs, "time", .5), get_kwarg_item(kwargs, "height_of_path", 0)
              self.initial_distance = get_kwarg_item(kwargs, "initial_distance", 0)

              # Adding the initial_distance, so it that is the height of the parabola
              self.set_all_variables(self.height_of_path + self.initial_distance, self.time, self.initial_distance)

          def run(self, is_reset_event, is_start_event, is_using_everything=False, is_changing_coordinates=True):
              """ Runs the code for the game_object following the physics path

                  Args:
                      is_reset_event (bool): if True it will call reset()
                      is_start_event (bool): if True it will call start()
                      is_using_everything (bool): if True it will use both velocity and acceleration and if False will just use velocity

                  Returns:
                      None
              """

              self.is_using_everything_this_cycle = is_using_everything

              # Calling the super method, but being explicit about which one I am looking for
              PhysicsFollowablePath.run(self, is_reset_event, is_start_event, is_changing_coordinates)

          def set_initial_distance(self, initial_distance):
              """Sets the initial distance, so the height of the parabola is equal to the vertex"""

              self.initial_distance = initial_distance
              self.set_all_variables(self.initial_distance + self.height_of_path, self.time, self.initial_distance)

          def get_velocity_displacement(self):
              """
                   Returns:
                      float: the displacement from velocity (the last_time - start_time)"""

              return self.get_displacement_due_to_velocity(self.last_time, self.current_time)

          def get_acceleration_displacement(self):
              """
                   Returns:
                      float: the distance from acceleration with gravity"""

              return self.get_displacement_due_to_acceleration(self.last_time, self.current_time)

          def get_total_displacement(self):
              """
                   Returns:
                      float: the displacement from both velocity and acceleration"""

              return self.get_velocity_displacement() + self.get_acceleration_displacement()

          def get_acceleration_displacement_from_time(self, time):
              """
                   Returns:
                      float: the displacement from acceleration at that time"""

              return self.get_displacement_due_to_acceleration(0, time)

          def get_final_velocity(self):
              """
                   Returns:
                      float: the velocity from acceleration (assumes initial_velocity is 0)"""

              return self.acceleration * self.current_time

          def get_value_at_time(self, time):
              """
                   Returns:
                      object: the value of the attribute this path is modifying at 'time'"""

              if self.is_using_everything_this_cycle:
                  self.get_distance(time)

              else:
                  return self.get_displacement_due_to_velocity(0, time)

          def get_delta_value(self, start_time, end_time):
              """
                   Returns:
                      object: the delta value of the attribute within the domain [start_time, end_time]"""

              if self.is_using_everything_this_cycle:
                  self.get_distance(end_time)

              else:
                  return self.get_displacement_due_to_velocity(start_time, end_time)

  ### Ancestors

  - FollowablePath
  - abc.ABC
  - PhysicsFunction

  ### Subclasses

  - PhysicsPath

  ### Class variables

  `var all_distance`
  `var attribute_modifying`
  `var current_time`
  `var game_object`
  `var has_max_time`
  `var height_of_path`
  `var is_started`
  `var is_using_everything_this_cycle`
  `var last_delta_time`
  `var last_time`
  `var max_time`
  `var time`

  ### Methods

  `def get_acceleration_displacement(self)`

    ## Returns

    `float`
      the distance from acceleration with gravity
    Expand source code

        def get_acceleration_displacement(self):
            """
                 Returns:
                    float: the distance from acceleration with gravity"""

            return self.get_displacement_due_to_acceleration(self.last_time, self.current_time)

  `def get_acceleration_displacement_from_time(self, time)`

    ## Returns

    `float`
      the displacement from acceleration at that time
    Expand source code

        def get_acceleration_displacement_from_time(self, time):
            """
                 Returns:
                    float: the displacement from acceleration at that time"""

            return self.get_displacement_due_to_acceleration(0, time)

  `def get_final_velocity(self)`

    ## Returns

    `float`
      the velocity from acceleration (assumes initial_velocity is 0)
    Expand source code

        def get_final_velocity(self):
            """
                 Returns:
                    float: the velocity from acceleration (assumes initial_velocity is 0)"""

            return self.acceleration * self.current_time

  `def get_total_displacement(self)`

    ## Returns

    `float`
      the displacement from both velocity and acceleration
    Expand source code

        def get_total_displacement(self):
            """
                 Returns:
                    float: the displacement from both velocity and acceleration"""

            return self.get_velocity_displacement() + self.get_acceleration_displacement()

  `def get_velocity_displacement(self)`

    ## Returns

    `float`
      the displacement from velocity (the last_time - start_time)
    Expand source code

        def get_velocity_displacement(self):
            """
                 Returns:
                    float: the displacement from velocity (the last_time - start_time)"""

            return self.get_displacement_due_to_velocity(self.last_time, self.current_time)

  `def run(self, is_reset_event, is_start_event, is_using_everything=False, is_changing_coordinates=True)`

    Runs the code for the game_object following the physics path

    ## Args

    `is_reset_event` :`bool`
      if True it will call reset()
    `is_start_event` :`bool`
      if True it will call start()
    `is_using_everything` :`bool`
      if True it will use both velocity and acceleration and if False will just use velocity

    ## Returns

    None

    Expand source code

        def run(self, is_reset_event, is_start_event, is_using_everything=False, is_changing_coordinates=True):
            """ Runs the code for the game_object following the physics path

                Args:
                    is_reset_event (bool): if True it will call reset()
                    is_start_event (bool): if True it will call start()
                    is_using_everything (bool): if True it will use both velocity and acceleration and if False will just use velocity

                Returns:
                    None
            """

            self.is_using_everything_this_cycle = is_using_everything

            # Calling the super method, but being explicit about which one I am looking for
            PhysicsFollowablePath.run(self, is_reset_event, is_start_event, is_changing_coordinates)

  `def set_initial_distance(self, initial_distance)`

    Sets the initial distance, so the height of the parabola is equal to the vertex

    Expand source code

        def set_initial_distance(self, initial_distance):
            """Sets the initial distance, so the height of the parabola is equal to the vertex"""

            self.initial_distance = initial_distance
            self.set_all_variables(self.initial_distance + self.height_of_path, self.time, self.initial_distance)

  ### Inherited members

  - `FollowablePath`:
    - `get_delta_value`
    - `get_value_at_time`
    - `has_finished`
    - `is_done`
    - `reset`
    - `restart`
    - `start`
  - `PhysicsFunction`:
    - `get_a_b_and_c`
    - `get_displacement`
    - `get_displacement_due_to_acceleration`
    - `get_displacement_due_to_velocity`
    - `get_distance`
    - `get_full_cycle_time`
    - `get_indefinite_integral_of_acceleration_equation`
    - `get_indefinite_integral_of_position_equation`
    - `get_indefinite_integral_of_velocity_equation`
    - `get_time_to_vertex`
    - `get_times_to_point`
    - `get_velocity_using_displacement`
    - `get_velocity_using_time`
    - `get_vertex`
    - `set_acceleration_with_displacement`
    - `set_acceleration_with_velocity`
    - `set_all_variables`
    - `set_variables`
    - `set_velocity_with_displacement`