### Navigation

- index
- next |
- previous |
- Ren'Py Visual Novel Engine v6.12.0 documentation

# Other Functions

We're in the process of migrating the documentation over to a new tool. As not every page has been migrated yet, this exists to document new functionality that has no other place to go.

`AlphaDissolve`(control, delay=0.0, alpha=False, reverse=False)

  This transition uses a control displayable (almost always some sort of animated transform) to transition from one screen to another. The transform is evaluated. The new screen is used where the transform is opaque, and the old image is used when it is transparent.

  control
    The control transform.
  delay
    The time the transition takes, before ending.
  alpha
    If true, the image is composited with what's behind it. If false, the default, the image is opaque and overwrites what's behind it.
  reverse
    If true, the alpha channel is reversed. Opaque areas are taken from the old image, while transparent areas are taken from the new image.

`MoveTransition`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`ease`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`easeinbottom`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`easeinleft`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`easeinright`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`easeintop`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`easeoutbottom`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`easeoutleft`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`easeoutright`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`easeouttop`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`move`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`moveinbottom`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`moveinleft`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`moveinright`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`moveintop`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`moveoutbottom`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`moveoutleft`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`moveoutright`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`moveouttop`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`zoomin`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`zoominout`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`zoomout`(delay, factory=None, enter_factory=None, leave_factory=None, old=False, layers=['master'])

  This transition attempts to find images that have changed position, and moves them from the old position to the new transition, taking delay seconds to complete the move.

  If factory is given, it is expected to be a function that takes as arguments: an old position, a new position, the delay, and a displayable, and to return a displayable as an argument. If not given, the default behavior is to move the displayable from the starting to the ending positions. Positions are always given as (xpos, ypos, xanchor, yanchor) tuples.

  If enter_factory or leave_factory are given, they are expected to be functions that take as arguments a position, a delay, and a displayable, and return a displayable. They are applied to displayables that are entering or leaving the scene, respectively. The default is to show in place displayables that are entering, and not to show those that are leaving.

  If old is True, then factory moves the old displayable with the given tag. Otherwise, it moves the new displayable with that tag.

  layers is a list of layers that the transition will be applied to.

  Images are considered to be the same if they have the same tag, in the same way that the tag is used to determine which image to replace or to hide. They are also considered to be the same if they have no tag, but use the same displayable.

  Computing the order in which images are displayed is a three-step process. The first step is to create a list of images that preserves the relative ordering of entering and moving images. The second step is to insert the leaving images such that each leaving image is at the lowest position that is still above all images that were below it in the original scene. Finally, the list is sorted by zorder, to ensure no zorder violations occur.

  If you use this transition to slide an image off the side of the screen, remember to hide it when you are done. (Or just use a leave_factory.)

`renpy.``focus_coordinates`()

  This attempts to find the coordinates of the currently-focused displayable. If it can, it will return them as a (x, y, w, h) tuple. If not, it will return a (None, None, None, None) tuple.

`renpy.``get_renderer_info`()

  Returns a dictionary, giving information about the renderer Ren'Py is currently using. The dictionary has one required key:

  `"renderer"`
    One of `"gl"` or `"sw"`, corresponding to the OpenGL and software renderers, respectively.

  Other, renderer-specific, keys may also exist. The dictionary should be treated as immutable. This should only be called once the display has been started (that is, after the init code is finished).

`renpy.``image_size`(im)

  Given an image manipulator, loads it and returns a (`width`, `height`) tuple giving its size.

  This reads the image in from disk and decompresses it, without using the image cache. This can be slow.

`renpy.``list_files`(common=False)

  Lists the files in the game directory and archive files. Returns a list of files, with / as the directory separator.

  common
    If true, files in the common directory are included in the listing.

`renpy.``notify`(message)

  Causes Ren'Py to display the message using the notify screen. By default, this will cause the message to be dissolved in, displayed for two seconds, and dissolved out again.

  This is useful for actions that otherwise wouldn't produce feedback, like screenshots or quicksaves.

  Only one notification is displayed at a time. If a second notification is displayed, the first notification is replaced.

`renpy.music.``register_channel`(name, mixer=None, loop=None, stop_on_mute=True, tight=False, file_prefix='', file_suffix='', buffer_queue=True)

  This registers a new audio channel named name. Audio can then be played on the channel by supplying the channel name to the play or queue statements.

  mixer
    The name of the mixer the channel uses. By default, Ren'Py knows about the "music", "sfx", and "voice" mixers. Using other names is possible, but may require changing the preferences screens.
  loop
    If true, sounds on this channel loop by default.
  stop_on_mute
    If true, music on the channel is stopped when the channel is muted.
  tight
    If true, sounds will loop even when fadeout is occuring. This should be set to True for a sound effects or seamless music channel, and False if the music fades out on its own.
  file_prefix
    A prefix that is prepended to the filenames of the sound files being played on this channel.
  file_suffix
    A suffix that is appended to the filenames of the sound files being played on this channel.
  buffer_queue
    Should we buffer the first second or so of a queued file? This should be True for audio, and False for movie playback.

`layout.``yesno_screen`(message, yes=None, no=None)

  This causes the a yes/no prompt screen with the given message to be displayed. The screen will be hidden when the user hits yes or no.

  message
    The message that will be displayed.
  yes
    An action that is run when the user chooses yes.
  no
    An action that is run when the user chooses no.

### Navigation

- index
- next |
- previous |
- Ren'Py Visual Novel Engine v6.12.0 documentation