game_qu.base.count_event API documentation

# Module `game_qu.base.count_event`

Expand source code

    class CountEvent:
        """ An event that keeps track how many times an action should be performed. Unless otherwise specified, the function
            calls have no impact on the value of 'times_needed_to_complete.' This guarantees that the event is revertable
            meaning that calling reset() will put the 'current_count' to 'times_needed_to_complete.' Also
            the event can be activated and disabled. If it is disabled, boolean method calls will always return False and
            the event is no longer mutable."""

        count_needed = 0
        current_count = 0
        is_infinite = False  # Whether this count event can be completed (is a finite number or an infinite number)
        is_active = True

        def __init__(self, count_needed):
            """ Initializes the object

                Args:
                    count_needed (int): the number of times this event must happen to be done"""

            self.count_needed = count_needed
            self.current_count = count_needed

        def set_times_needed_to_complete(self, count_needed):
            """ Sets 'count needed' to the value provided. If you want the current count to update call 'reset()'

                Args:
                    count_needed (int): the number of times this event must happen to be done"""

            if self.is_active:
                self.count_needed = count_needed

        def increase_times_needed_to_complete(self, amount):
            """Increases the count by amount"""

            if self.is_active:
                self.current_count += amount

        def decrease_times_needed_to_complete(self, amount):
            """Decreases the count by amount"""

            if self.is_active:
                self.current_count -= amount

        def mutate_times_needed_to_complete(self, amount):
            """ Increases the count by amount (if it is negative, then count is decreased). This is the same as calling
                'increase_times_needed_to_complete,' but adding a negative number to an increase method does not make
                logical sense as far as an API perspective."""

            if self.is_active:
                self.increase_times_needed_to_complete(amount)

        def increment(self):
            """Increments count by 1"""

            if self.is_active:
                self.current_count += 1

        def decrement(self):
            """Decrements count by 1"""

            if self.is_active:
                self.current_count -= 1

        def is_done(self):
            """Whether the amount of times this event must happen to be done is less than or equal to 0"""

            return (self.current_count <= 0 or self.is_infinite) and self.is_active

        def is_done_this_cycle(self):
            """Whether the count is equal to 0"""

            return self.current_count == 0 and self.is_active

        def reset(self):
            """ Resets the event, so the count is set to what the user specified in either
                the __init__ method or the 'set_times_needed_to_complete;' the most recent call is chosen"""

            if self.is_active:
                self.current_count = self.count_needed

        def set_is_active(self, is_active):
            """ Sets whether this Event is active. If it is not active, all functions that return a boolean will return False
                and the event cannot be mutated. If it is active, all operations behave 'normally'"""

            self.is_active = is_active

        def activate(self):
            """ Activates this function. If it is not active, all functions that return a boolean will return False and the
                event cannot be mutated. If it is active, all operations behave 'normally'"""

            self.set_is_active(True)

        def disable(self):
            """ Activates this function. If it is not active, all functions that return a boolean will return False and the
                event cannot be mutated. If it is active, all operations behave 'normally'"""

            self.set_is_active(False)

        def get_is_active(self):
            """
                 Returns:
                boolean; whether the function is active. If it is not active, all functions that return a boolean
                will return False and the event cannot be mutated. If it is active, all operations behave 'normally'"""

            return self.is_active

        def set_is_infinite(self, is_infinite):
            """Sets whether this event is infinite (if it is infinite it cannot be completed)"""

            self.is_infinite = is_infinite

        def make_finite(self):
            """Makes this event finite (meaning it can be completed)"""

            self.set_is_infinite(False)

        def make_infinite(self):
            """Makes this event infinite (it cannot be completed)"""

            self.set_is_infinite(True)

        def get_is_infinite(self):
            """
                 Returns:
                boolean; whether this event is infinite (if it is infinite it cannot be completed)"""

            return self.is_infinite

        def current_count_is_positive(self):
            """
                 Returns:
                    boolean: whether the positive (count > 0)"""

            return self.current_count > 0 and self.is_active

        def current_count_is_negative(self):
            """
                 Returns:
                    boolean: whether the count is negative (count < 0)"""

            return self.current_count < 0 and self.is_active

        def get_count_needed(self):
            """
                 Returns:
                    int: the number of times this event must happen to be done"""

            return self.count_needed

        def get_current_count(self):
            """
                 Returns:
                    int: the current count of this event"""

            return self.current_count

## Classes

`class CountEvent (count_needed)`

  An event that keeps track how many times an action should be performed. Unless otherwise specified, the function calls have no impact on the value of 'times_needed_to_complete.' This guarantees that the event is revertable meaning that calling reset() will put the 'current_count' to 'times_needed_to_complete.' Also the event can be activated and disabled. If it is disabled, boolean method calls will always return False and the event is no longer mutable.

  Initializes the object

  ## Args

  `count_needed` :`int`
    the number of times this event must happen to be done
  Expand source code

      class CountEvent:
          """ An event that keeps track how many times an action should be performed. Unless otherwise specified, the function
              calls have no impact on the value of 'times_needed_to_complete.' This guarantees that the event is revertable
              meaning that calling reset() will put the 'current_count' to 'times_needed_to_complete.' Also
              the event can be activated and disabled. If it is disabled, boolean method calls will always return False and
              the event is no longer mutable."""

          count_needed = 0
          current_count = 0
          is_infinite = False  # Whether this count event can be completed (is a finite number or an infinite number)
          is_active = True

          def __init__(self, count_needed):
              """ Initializes the object

                  Args:
                      count_needed (int): the number of times this event must happen to be done"""

              self.count_needed = count_needed
              self.current_count = count_needed

          def set_times_needed_to_complete(self, count_needed):
              """ Sets 'count needed' to the value provided. If you want the current count to update call 'reset()'

                  Args:
                      count_needed (int): the number of times this event must happen to be done"""

              if self.is_active:
                  self.count_needed = count_needed

          def increase_times_needed_to_complete(self, amount):
              """Increases the count by amount"""

              if self.is_active:
                  self.current_count += amount

          def decrease_times_needed_to_complete(self, amount):
              """Decreases the count by amount"""

              if self.is_active:
                  self.current_count -= amount

          def mutate_times_needed_to_complete(self, amount):
              """ Increases the count by amount (if it is negative, then count is decreased). This is the same as calling
                  'increase_times_needed_to_complete,' but adding a negative number to an increase method does not make
                  logical sense as far as an API perspective."""

              if self.is_active:
                  self.increase_times_needed_to_complete(amount)

          def increment(self):
              """Increments count by 1"""

              if self.is_active:
                  self.current_count += 1

          def decrement(self):
              """Decrements count by 1"""

              if self.is_active:
                  self.current_count -= 1

          def is_done(self):
              """Whether the amount of times this event must happen to be done is less than or equal to 0"""

              return (self.current_count <= 0 or self.is_infinite) and self.is_active

          def is_done_this_cycle(self):
              """Whether the count is equal to 0"""

              return self.current_count == 0 and self.is_active

          def reset(self):
              """ Resets the event, so the count is set to what the user specified in either
                  the __init__ method or the 'set_times_needed_to_complete;' the most recent call is chosen"""

              if self.is_active:
                  self.current_count = self.count_needed

          def set_is_active(self, is_active):
              """ Sets whether this Event is active. If it is not active, all functions that return a boolean will return False
                  and the event cannot be mutated. If it is active, all operations behave 'normally'"""

              self.is_active = is_active

          def activate(self):
              """ Activates this function. If it is not active, all functions that return a boolean will return False and the
                  event cannot be mutated. If it is active, all operations behave 'normally'"""

              self.set_is_active(True)

          def disable(self):
              """ Activates this function. If it is not active, all functions that return a boolean will return False and the
                  event cannot be mutated. If it is active, all operations behave 'normally'"""

              self.set_is_active(False)

          def get_is_active(self):
              """
                   Returns:
                  boolean; whether the function is active. If it is not active, all functions that return a boolean
                  will return False and the event cannot be mutated. If it is active, all operations behave 'normally'"""

              return self.is_active

          def set_is_infinite(self, is_infinite):
              """Sets whether this event is infinite (if it is infinite it cannot be completed)"""

              self.is_infinite = is_infinite

          def make_finite(self):
              """Makes this event finite (meaning it can be completed)"""

              self.set_is_infinite(False)

          def make_infinite(self):
              """Makes this event infinite (it cannot be completed)"""

              self.set_is_infinite(True)

          def get_is_infinite(self):
              """
                   Returns:
                  boolean; whether this event is infinite (if it is infinite it cannot be completed)"""

              return self.is_infinite

          def current_count_is_positive(self):
              """
                   Returns:
                      boolean: whether the positive (count > 0)"""

              return self.current_count > 0 and self.is_active

          def current_count_is_negative(self):
              """
                   Returns:
                      boolean: whether the count is negative (count < 0)"""

              return self.current_count < 0 and self.is_active

          def get_count_needed(self):
              """
                   Returns:
                      int: the number of times this event must happen to be done"""

              return self.count_needed

          def get_current_count(self):
              """
                   Returns:
                      int: the current count of this event"""

              return self.current_count

  ### Class variables

  `var count_needed`
  `var current_count`
  `var is_active`
  `var is_infinite`

  ### Methods

  `def activate(self)`

    Activates this function. If it is not active, all functions that return a boolean will return False and the event cannot be mutated. If it is active, all operations behave 'normally'

    Expand source code

        def activate(self):
            """ Activates this function. If it is not active, all functions that return a boolean will return False and the
                event cannot be mutated. If it is active, all operations behave 'normally'"""

            self.set_is_active(True)

  `def current_count_is_negative(self)`

    ## Returns

    `boolean`
      whether the count is negative (count < 0)
    Expand source code

        def current_count_is_negative(self):
            """
                 Returns:
                    boolean: whether the count is negative (count < 0)"""

            return self.current_count < 0 and self.is_active

  `def current_count_is_positive(self)`

    ## Returns

    `boolean`
      whether the positive (count > 0)
    Expand source code

        def current_count_is_positive(self):
            """
                 Returns:
                    boolean: whether the positive (count > 0)"""

            return self.current_count > 0 and self.is_active

  `def decrease_times_needed_to_complete(self, amount)`

    Decreases the count by amount

    Expand source code

        def decrease_times_needed_to_complete(self, amount):
            """Decreases the count by amount"""

            if self.is_active:
                self.current_count -= amount

  `def decrement(self)`

    Decrements count by 1

    Expand source code

        def decrement(self):
            """Decrements count by 1"""

            if self.is_active:
                self.current_count -= 1

  `def disable(self)`

    Activates this function. If it is not active, all functions that return a boolean will return False and the event cannot be mutated. If it is active, all operations behave 'normally'

    Expand source code

        def disable(self):
            """ Activates this function. If it is not active, all functions that return a boolean will return False and the
                event cannot be mutated. If it is active, all operations behave 'normally'"""

            self.set_is_active(False)

  `def get_count_needed(self)`

    ## Returns

    `int`
      the number of times this event must happen to be done
    Expand source code

        def get_count_needed(self):
            """
                 Returns:
                    int: the number of times this event must happen to be done"""

            return self.count_needed

  `def get_current_count(self)`

    ## Returns

    `int`
      the current count of this event
    Expand source code

        def get_current_count(self):
            """
                 Returns:
                    int: the current count of this event"""

            return self.current_count

  `def get_is_active(self)`

    Returns: boolean; whether the function is active. If it is not active, all functions that return a boolean will return False and the event cannot be mutated. If it is active, all operations behave 'normally'

    Expand source code

        def get_is_active(self):
            """
                 Returns:
                boolean; whether the function is active. If it is not active, all functions that return a boolean
                will return False and the event cannot be mutated. If it is active, all operations behave 'normally'"""

            return self.is_active

  `def get_is_infinite(self)`

    Returns: boolean; whether this event is infinite (if it is infinite it cannot be completed)

    Expand source code

        def get_is_infinite(self):
            """
                 Returns:
                boolean; whether this event is infinite (if it is infinite it cannot be completed)"""

            return self.is_infinite

  `def increase_times_needed_to_complete(self, amount)`

    Increases the count by amount

    Expand source code

        def increase_times_needed_to_complete(self, amount):
            """Increases the count by amount"""

            if self.is_active:
                self.current_count += amount

  `def increment(self)`

    Increments count by 1

    Expand source code

        def increment(self):
            """Increments count by 1"""

            if self.is_active:
                self.current_count += 1

  `def is_done(self)`

    Whether the amount of times this event must happen to be done is less than or equal to 0

    Expand source code

        def is_done(self):
            """Whether the amount of times this event must happen to be done is less than or equal to 0"""

            return (self.current_count <= 0 or self.is_infinite) and self.is_active

  `def is_done_this_cycle(self)`

    Whether the count is equal to 0

    Expand source code

        def is_done_this_cycle(self):
            """Whether the count is equal to 0"""

            return self.current_count == 0 and self.is_active

  `def make_finite(self)`

    Makes this event finite (meaning it can be completed)

    Expand source code

        def make_finite(self):
            """Makes this event finite (meaning it can be completed)"""

            self.set_is_infinite(False)

  `def make_infinite(self)`

    Makes this event infinite (it cannot be completed)

    Expand source code

        def make_infinite(self):
            """Makes this event infinite (it cannot be completed)"""

            self.set_is_infinite(True)

  `def mutate_times_needed_to_complete(self, amount)`

    Increases the count by amount (if it is negative, then count is decreased). This is the same as calling 'increase_times_needed_to_complete,' but adding a negative number to an increase method does not make logical sense as far as an API perspective.

    Expand source code

        def mutate_times_needed_to_complete(self, amount):
            """ Increases the count by amount (if it is negative, then count is decreased). This is the same as calling
                'increase_times_needed_to_complete,' but adding a negative number to an increase method does not make
                logical sense as far as an API perspective."""

            if self.is_active:
                self.increase_times_needed_to_complete(amount)

  `def reset(self)`

    Resets the event, so the count is set to what the user specified in either the init method or the 'set_times_needed_to_complete;' the most recent call is chosen

    Expand source code

        def reset(self):
            """ Resets the event, so the count is set to what the user specified in either
                the __init__ method or the 'set_times_needed_to_complete;' the most recent call is chosen"""

            if self.is_active:
                self.current_count = self.count_needed

  `def set_is_active(self, is_active)`

    Sets whether this Event is active. If it is not active, all functions that return a boolean will return False and the event cannot be mutated. If it is active, all operations behave 'normally'

    Expand source code

        def set_is_active(self, is_active):
            """ Sets whether this Event is active. If it is not active, all functions that return a boolean will return False
                and the event cannot be mutated. If it is active, all operations behave 'normally'"""

            self.is_active = is_active

  `def set_is_infinite(self, is_infinite)`

    Sets whether this event is infinite (if it is infinite it cannot be completed)

    Expand source code

        def set_is_infinite(self, is_infinite):
            """Sets whether this event is infinite (if it is infinite it cannot be completed)"""

            self.is_infinite = is_infinite

  `def set_times_needed_to_complete(self, count_needed)`

    Sets 'count needed' to the value provided. If you want the current count to update call 'reset()'

    ## Args

    `count_needed` :`int`
      the number of times this event must happen to be done
    Expand source code

        def set_times_needed_to_complete(self, count_needed):
            """ Sets 'count needed' to the value provided. If you want the current count to update call 'reset()'

                Args:
                    count_needed (int): the number of times this event must happen to be done"""

            if self.is_active:
                self.count_needed = count_needed