Прочие функции и переменные

На этой странице перечислены и документированы различные прочие функции и переменные, которые не подходят для размещения в других местах.

Версия Ren'Py

renpy.version(tuple=False)

Если tuple равно false, возвращает строку, содержащую "Ren'Py ", за которой следует текущая версия Ren'Py.

Если tuple равно true, возвращает кортеж, содержащий каждый компонент версии в виде целого числа.

renpy.version_string: Номер версии Ren'Py в виде строки формата "Ren'Py 1.2.3.456".

renpy.version_only: Номер версии Ren'Py без префикса "Ren'Py". Строка формата "1.2.3.456".

renpy.version_tuple

Номер версии Ren'Py в виде кортежа (tuple) формата (1, 2, 3, 456).

Это именованный кортеж (namedtuple) с четырьмя полями: major, minor, patch, и commit.

renpy.version_name: Читаемое человеком название версии, вида "Example Version.".

renpy.license: Строка, содержащая текст лицензии, который должен быть включен в экран "О программе" (about screen).

Определение платформы

Ren'Py включает в себя ряд переменных, которые устанавливаются в зависимости от того, на какой платформе он работает.

renpy.windows: Имеет истинное значение при запуске в Windows.

renpy.macintosh: Имеет истинное значение при запуске в macOS.

renpy.linux: Имеет истинное значение при запуске в Linux или других POSIX-подобных операционных системах.

renpy.android: Имеет истинное значение при запуске на Android.

renpy.ios: Имеет истинное значение при запуске на iOS.

renpy.emscripten: Имеет истинное значение при запуске в браузере. Это значение, в частности, модуль emscripten, который позволяет вам взаимодействовать с браузером, см. renpy.emscripten.run_script() и подобные функции.

renpy.mobile: Имеет истинное значение при запуске на Android, iOS или в браузере.

Эти переменные устанавливаются только при запуске на реальных устройствах, а не в эмуляторах. Они больше предназначены для использования в специфичном для платформы коде на Python. Для компоновки отображения используйте варианты экранов.

Профилирование памяти

renpy.diff_memory(update=True, skip_constants=False)

Профилирует использование памяти объектами, surface и текстурами в Ren'Py и игре. Записывает (в memory.txt и stdout) разницу в использовании памяти с момента последнего вызова этой функции с update равным true.

Учёт ведётся по именам в хранилище (store) и в реализации Ren'Py, из которых доступна память. Если объект доступен по более чем одному имени, он присваивается тому имени, от которого он наиболее прямо доступен.

skip_constants: Если True, профилировщик пропустит сканирование больших контейнеров Ren'Py, которые должны быть неизменяемыми после запуска.

Поскольку эта функция должна сканировать всю память, используемую Ren'Py, её выполнение может занять много времени.

renpy.profile_memory(fraction=1.0, minimum=0, skip_constants=False)

Профилирует использование памяти объектами, surface и текстурами в Ren'Py и игре. Записывает отчёт об использовании памяти в файл memory.txt и stdout.

Учёт ведётся по именам в хранилище (store) и в реализации Ren'Py, из которых доступна память. Если объект доступен по более чем одному имени, он присваивается тому имени, от которого он наиболее прямо доступен.

fraction: Доля от общего использования памяти для отображения. 1.0 покажет всё использование памяти, .9 покажет топ 90%.
minimum: Если на имя приходится меньше minimum байтов памяти, оно не будет выведено.
skip_constants: Если True, профилировщик пропустит сканирование больших контейнеров Ren'Py, которые должны быть неизменяемыми после запуска.

Поскольку эта функция должна сканировать всю память, используемую Ren'Py, её выполнение может занять много времени.

renpy.profile_rollback(): Профилирует память, используемую системой отката (rollback). Записывает (в memory.txt и stdout) память, используемую системой отката. Эта функция пытается учесть память для отката, используемую различными переменными хранилища, а также внутренними аспектами системы отката.

renpy.random

Этот объект является генератором случайных чисел, который реализует интерфейс генерации случайных чисел Python. Случайность может быть сгенерирована путем вызова различных методов, которые предоставляет этот объект. Полный список см. в документации Python, но наиболее полезными являются:

renpy.random.random()

Возвращает следующее случайное число с плавающей точкой в диапазоне (0.0, 1.0).

renpy.random.randint(a, b)

Возвращает случайное целое число N такое, что a <= N <= b.

renpy.random.choice(seq)

Возвращает случайный элемент из непустой последовательности seq.

renpy.random.shuffle(seq)

Перемешивает элементы последовательности seq на месте. Это не возвращает список, а изменяет существующий.

В отличие от стандартного генератора случайных чисел Python, этот объект взаимодействует с откатом (rollback), генерируя те же числа независимо от того, сколько раз мы откатываемся. Его следует использовать вместо стандартного модуля random Python.

# вернуть случайное число с плавающей точкой от 0 до 1
$ randfloat = renpy.random.random()

# вернуть случайное целое число от 1 до 20
$ d20roll = renpy.random.randint(1, 20)

# вернуть случайный элемент из списка
$ randfruit = renpy.random.choice(['apple', 'orange', 'plum'])

renpy.random.Random(seed=None)

Возвращает новый объект генератора случайных чисел, отдельный от основного, инициализированный указанным значением, если оно предоставлено.

SDL

Доступ к DLL SDL2 можно получить с помощью renpy.get_sdl_dll(). Это позволяет использовать функции SDL2 напрямую. Однако их использование часто требует знания модуля ctypes Python.

Нет никаких гарантий относительно версии SDL2, включенной в Ren'Py, включая то, какие функции будут или не будут скомпилированы. Эти функции могут не работать на платформах, которые в остальном могут запускать Ren'Py. Важно проверить на значение None перед продолжением.

В следующем примере позиция окна будет взята из SDL2:

init python:

    import ctypes

    def get_window_position():
        """Retrieves the position of the window from SDL2.

        Returns the (x, y) of the upper left corner of the window, or
        (0, 0) if it's not known.
        """

        sdl = renpy.get_sdl_dll()

        if sdl is None:
            return (0, 0)

        win = renpy.get_sdl_window_pointer()

        if win is None:
            return (0, 0)

        x = ctypes.c_int()
        y = ctypes.c_int()

        result = sdl.SDL_GetWindowPosition(win, ctypes.byref(x), ctypes.byref(y))

        return result

renpy.get_sdl_dll(): Возвращает объект ctypes.cdll, который ссылается на библиотеку, содержащую экземпляр SDL2, используемый Ren'Py. Если это не удается, возвращается None.

renpy.get_sdl_window_pointer()

Тип результата:: ctypes.c_void_p | None

Возвращает указатель на главное окно, или None, если главное окно не отображается (или возникает какая-то другая проблема).

Разное

renpy.add_python_directory(path: str): Добавляет path в список путей для поиска модулей и пакетов Python. Путь должен быть строкой относительно каталога игры. Эта функция должна быть вызвана до инструкции import.

renpy.add_to_all_stores(name, value)

Добавляет value под именем name во все определенные создателем пространства имен. Если имя уже существует в каком-либо пространстве имен, для него ничего не делается.

Эту функцию можно запускать только из блока init. Запуск этой функции после начала игры является ошибкой.

renpy.can_fullscreen(): Возвращает True, если текущая платформа поддерживает полноэкранный режим, в противном случае — False.

renpy.capture_focus(name='default')

Если displayable в данный момент находится в фокусе, захватывает его ограничивающий прямоугольник и сохраняет его под именем name. В противном случае удаляет любой фокус, сохраненный под именем name.

Захваченные фокусы не сохраняются при сохранении игры.

name: Должна быть строкой. Имя "tooltip" является особенным, так как оно автоматически захватывается, когда displayable с подсказкой (tooltip) получает фокус.

renpy.choice_for_skipping()

Сообщает Ren'Py о скором появлении выбора. В настоящее время это имеет два эффекта:

Если Ren'Py находится в режиме пропуска (skipping), и настройка "Пропускать после выбора" установлена на остановку, пропуск прекращается.
Срабатывает автосохранение.

renpy.clear_capture_focus(name='default'): Очищает захваченный фокус с именем name. Если name равно None, очищаются все захваченные фокусы.

renpy.clear_game_runtime(): Сбрасывает счетчик времени игры.

renpy.clear_retain(layer='screens', prefix='_retain'): Очищает все сохраненные экраны (retained screens).

renpy.confirm(message, **kwargs)

Эта функция вызывает отображение экрана с запросом да/нет с заданным сообщением, который скрывается, когда игрок нажимает "да" или "нет".

Возвращает True, если игрок нажимает "да", и False, если нажимает "нет".

message: Сообщение, которое будет отображено.

Дополнительные именованные аргументы, не начинающиеся с _, передаются экрану.

Смотрите Confirm() для аналогичного Action.

renpy.count_dialogue_blocks(): Возвращает количество блоков диалога на исходном языке игры.

renpy.count_newly_seen_dialogue_blocks(): Возвращает количество блоков диалога, которые пользователь увидел впервые в течение текущей сессии.

renpy.count_seen_dialogue_blocks(): Возвращает количество блоков диалога, которые пользователь видел в любом из прохождений текущей игры.

renpy.display_notify(message): Реализация по умолчанию для renpy.notify().

renpy.focus_coordinates(): Эта функция пытается найти координаты displayable, находящегося в фокусе в данный момент. Если это удается, она вернет их в виде кортежа (x, y, w, h). В противном случае она вернет кортеж (None, None, None, None).

renpy.force_autosave(take_screenshot=False, block=False)

Принудительно запускает автосохранение в фоновом режиме.

take_screenshot: Если True, будет сделан новый скриншот. Если False, будет использован существующий.
block: Если True, блокирует выполнение до завершения автосохранения.

renpy.free_memory(): Пытается освободить немного памяти. Полезно перед запуском мини-игры на основе renpygame.

renpy.full_restart(transition=False, *, save=False)

Вызывает перезапуск Ren'Py с возвратом пользователя в главное меню.

transition: Если задан, это переход, который нужно выполнить, или None, чтобы не выполнять переход. False использует config.end_game_transition.
save: Если true, игра сохраняется в _quit_slot перед тем, как Ren'Py перезапустится и вернет пользователя в главное меню.

renpy.get_game_runtime()

Возвращает счетчик времени игры.

Счетчик времени игры подсчитывает количество секунд, прошедших в ожидании ввода от пользователя в контексте верхнего уровня. (Он не учитывает время, проведенное в главном или игровом меню.)

renpy.get_image_load_log(age=None)

Генератор, который выдает лог активности загрузки изображений. За последние 100 загрузок изображений он возвращает:

Время загрузки изображения (в секундах с начала эпохи).
Имя файла загруженного изображения.
Логическое значение, которое равно true, если изображение было предзагружено, и false, если игра остановилась для его загрузки.

Записи упорядочены от новых к старым.

age: Если не None, включаются только изображения, загруженные за последние age секунд.

Лог загрузки изображений ведется только если config.developer = True.

renpy.get_menu_args(): Возвращает кортеж, содержащий аргументы (в виде кортежа) и именованные аргументы (в виде словаря), переданные текущей инструкции menu.

renpy.get_mouse_name(interaction=False)

Возвращает имя курсора мыши, который должен быть показан.

interaction: Если true, возвращает имя курсора, основанное на типе происходящего взаимодействия.

renpy.get_mouse_names(): Возвращает список имен курсоров мыши, которые могут быть отображены, в порядке приоритета.

renpy.get_mouse_pos(): Возвращает кортеж (x, y), указывающий положение указателя мыши или текущего места касания. Если устройство не поддерживает мышь и в данный момент нет касаний, x и y являются числами, но не имеют значения.

renpy.get_on_battery(): Возвращает True, если Ren'Py работает на устройстве, питающемся от внутренней батареи, или False, если устройство заряжается от какого-либо внешнего источника.

renpy.get_ongoing_transition(layer=None)

Возвращает переход, который выполняется в данный момент.

layer: Если None, возвращается переход верхнего уровня. В противном случае, это должна быть строка с именем слоя, и в этом случае возвращается переход для этого слоя.

renpy.get_physical_size(): Возвращает размер физического окна.

renpy.get_refresh_rate(precision=5)

Возвращает частоту обновления текущего экрана в виде числа с плавающей запятой, означающего количество кадров в секунду.

precision

Необработанные данные, которые получает Ren'Py, — это количество кадров в секунду, округленное до ближайшего целого числа. Это означает, что монитор, работающий с частотой 59.95 кадров в секунду, будет отображаться как 59 fps. Аргумент precision дополнительно снижает точность этого значения, так что допустимыми являются только значения, кратные precision.

Поскольку частота кадров мониторов обычно кратна 5 (25, 30, 60, 75 и 120), это, вероятно, повысит точность. Установка precision в 1 отключает эту функцию.

renpy.get_renderer_info() → renpy.display.core.RendererInfo

Возвращает словарь с информацией о рендерере, который в настоящее время использует Ren'Py. Определенные ключи:

"renderer": Строка, содержащая имя используемого рендерера.
"resizable": True, если окно можно изменять в размерах, и только в этом случае.
"additive": True, если рендерер поддерживает аддитивное смешивание (additive blending), и только в этом случае.
"model": Присутствует и имеет значение true, если поддерживается рендеринг на основе моделей.

При использовании рендерера GL2 также определены следующие ключи:

"gpu_vendor": Строка с названием производителя GPU.
"gpu_name": Строка с названием GPU.
"gpu_driver_version": Строка с версией драйвера.

Могут существовать и другие, специфичные для рендерера, ключи.

Словарь следует рассматривать как неизменяемый (immutable).

Эту функцию следует вызывать только после запуска дисплея (то есть, не раньше первого взаимодействия).

renpy.get_say_attributes()

Возвращает атрибуты, связанные с текущей инструкцией say, или None, если с этой инструкцией не связано никаких атрибутов.

Эта функция действительна только во время выполнения или предсказания инструкции say.

renpy.get_skipping(): Возвращает "slow", если Ren'Py находится в режиме пропуска (skipping), "fast", если Ren'Py в режиме быстрого пропуска, и None, если пропуск неактивен.

renpy.get_statement_name(): Получает имя текущей инструкции, строку вроде "say", "say-nvl" или "window hide". Это то же имя инструкции, которое используется с config.statement_callbacks.

renpy.get_transition(layer=None)

Получает переход для layer или для всей сцены, если layer равно None. Эта функция возвращает переход, который находится в очереди на выполнение во время следующего взаимодействия, или None, если такого перехода нет.

Используйте renpy.get_ongoing_transition(), чтобы получить переход, который выполняется в данный момент.

renpy.iconify(): Сворачивает игру в иконку.

renpy.include_module(name)

Аналогично renpy.load_module(), но вместо немедленной загрузки модуля, вставляет его в очередь init где-то после текущего узла AST.

Модуль не может содержать блоки init с приоритетом ниже, чем у блока, который его подключает. Например, если ваш модуль содержит блок init 10, самое позднее, где вы можете его загрузить, это init 10.

Загрузка модуля может происходить только из блока init.

renpy.invoke_in_main_thread(fn, *args, **kwargs)

Эта функция запускает заданную функцию с заданными аргументами в основном потоке. Функция выполняется в контексте взаимодействия, аналогичном обработчику событий. Предполагается, что она будет вызываться из отдельного потока, создание которого обрабатывается renpy.invoke_in_thread().

Если один поток планирует вызов нескольких функций, гарантируется, что они будут выполнены в том порядке, в котором они были запланированы:

def ran_in_a_thread():
    renpy.invoke_in_main_thread(a)
    renpy.invoke_in_main_thread(b)

В этом примере гарантируется, что a завершится до вызова b. Порядок вызовов из разных потоков не гарантируется.

Эту функцию нельзя вызывать на этапе init.

renpy.invoke_in_thread(fn, *args, **kwargs)

Вызывает функцию fn в фоновом потоке, передавая ей предоставленные позиционные и именованные аргументы. Перезапускает взаимодействие после возврата из потока.

Эта функция создает фоновый (daemon) поток, который будет автоматически остановлен при завершении работы Ren'Py.

Этот поток очень ограничен в том, что он может делать с API Ren'Py. Разрешено изменять переменные хранилища (store), а также вызывать следующие функции:

renpy.restart_interaction()
renpy.invoke_in_main_thread()
renpy.queue_event()

Большинство других частей API Ren'Py должны вызываться из основного потока.

Эта функция не работает на веб-платформе, кроме как немедленно возвращается без ошибки.

renpy.is_in_test(): Возвращает True, если Ren'Py в данный момент выполняет тест. Во время init эта функция всегда возвращает False.

renpy.is_init_phase(): Возвращает True, если Ren'Py в настоящее время выполняет init-код, в противном случае — False.

renpy.is_mouse_visible(): Возвращает True, если курсор мыши виден, в противном случае — False.

renpy.is_seen(ever=True)

Возвращает true, если текущая строка была просмотрена игроком.

Если ever равно true, проверяется, была ли строка просмотрена игроком когда-либо. Если false, проверяется, была ли строка просмотрена в текущем прохождении.

renpy.is_seen_allowed(): Возвращает False, только если идет повтор (replay) и события просмотра (seen) запрещены установкой config.no_replay_seen в True.

renpy.is_skipping(): Возвращает True, если Ren'Py в данный момент находится в режиме пропуска (в быстром или медленном режиме), в противном случае — False.

renpy.is_start_interact(): Возвращает True, если restart_interaction не был вызван во время текущего взаимодействия. Это можно использовать, чтобы определить, только ли началось взаимодействие или оно было перезапущено.

renpy.language_tailor(chars, cls)

Эта функция может быть использована для переопределения класса переноса строк для символа Юникода. Например, класс переноса для символа можно установить в ID, чтобы он рассматривался как идеограмма, что позволяет делать переносы до и после этого символа.

chars: Строка, содержащая каждый из символов для настройки.
cls: Строка, задающая класс символа. Это должен быть один из классов, определенных в Таблице 1 UAX #14: Unicode Line Breaking Algorithm.

renpy.last_say()

Возвращает объект, содержащий информацию о последней инструкции say.

Хотя эту функцию можно вызывать во время выполнения инструкции say, если инструкция использует обычный Character, информация будет о текущей инструкции say, а не о предыдущей.

who: Говорящий. Обычно это объект Character(), но это не обязательно.
what: Строка с произнесенным диалогом. Может быть None, если диалог еще не был показан, например, в начале игры.
args: Кортеж аргументов, переданных последней инструкции say.
kwargs: Словарь именованных аргументов, переданных последней инструкции say.

Предупреждение

Как и другие подобные функции, возвращаемый объект предназначен для краткосрочного использования после вызова функции. Не рекомендуется включать его в данные сохранения или заставлять его участвовать в откате.

renpy.load_module(name)

Загружает модуль Ren'Py с именем name. Модуль Ren'Py состоит из скрипта Ren'Py, который загружается в обычное пространство имен (store), и содержится в файле с именем name.rpym или name.rpymc. Если файл .rpym существует и новее соответствующего файла .rpymc, он загружается и создается новый файл .rpymc.

Все блоки init (и другой код init-фазы) в модуле выполняются до возврата этой функции. Возникает ошибка, если имя модуля не найдено или неоднозначно.

Загрузка модуля может происходить только из блока init.

renpy.load_string(s, filename='<string>')

Загружает s как скрипт Ren'Py, который можно вызывать.

Возвращает имя первой инструкции в s.

filename - это имя файла, из которого, как будет считаться, происходят инструкции в строке.

renpy.maximum_framerate(t): Заставляет Ren'Py отрисовывать экран с максимальной частотой кадров в течение t секунд. Если t равно None, отменяет запрос на максимальную частоту кадров.

renpy.munge(name, filename=None)

Искажает (munges) name, которое должно начинаться с __.

filename: Имя файла, в которое искажается имя. Если None, имя искажается в имя файла, содержащего вызов этой функции.

renpy.not_infinite_loop(delay): Сбрасывает таймер обнаружения бесконечного цикла на delay секунд.

renpy.notify(message)

Заставляет Ren'Py отобразить message с помощью экрана уведомлений. По умолчанию это приведет к тому, что сообщение появится с эффектом dissolve, будет отображаться в течение двух секунд и снова исчезнет с dissolve.

Это полезно для действий, которые в противном случае не давали бы обратной связи, таких как скриншоты или быстрые сохранения.

Одновременно отображается только одно уведомление. Если отображается второе уведомление, первое заменяется.

Эта функция просто вызывает config.notify, что позволяет заменить ее реализацию, присвоив новую функцию этой переменной.

renpy.open_url(url): Открывает URL в системном веб-браузере, если это возможно.

renpy.predicting(): Возвращает True, если Ren'Py в данный момент находится в фазе предсказания (predicting).

renpy.queue_event(name, up=False, **kwargs)

Ставит в очередь событие с заданным именем. Name должно быть одним из имен событий в config.keymap, или списком таких имен.

up: Должно быть False, когда событие начинается (например, при нажатии кнопки клавиатуры). Должно быть True, когда событие заканчивается (когда кнопка отпущена).

Событие ставится в очередь в момент вызова этой функции. Эта функция не будет работать для замены одного события другим - это изменит порядок событий. (Используйте config.keymap вместо этого.)

Этот метод является потокобезопасным (threadsafe).

renpy.quit(relaunch=False, status=0, save=False)

Эта функция вызывает полный выход из Ren'Py.

relaunch: Если True, Ren'Py запустит вторую свою копию перед выходом.
status: Код состояния, который Ren'Py вернет операционной системе. Обычно 0 — это успех, а положительные целые числа — неудача.
save: Если True, игра сохраняется в _quit_slot перед завершением работы Ren'Py.

renpy.quit_event(): Вызывает событие выхода, как если бы игрок нажал кнопку выхода в рамке окна.

renpy.reset_physical_size(): Пытается установить размер физического окна в значение, указанное с помощью renpy.config.physical_height и renpy.config.physical_width, или, если они не заданы, в размер, установленный с помощью renpy.config.screen_width и renpy.config.screen_height.

renpy.restart_interaction()

Перезапускает текущее взаимодействие. Среди прочего, это отображает изображения, добавленные на сцену, переоценивает экраны и запускает все переходы в очереди.

Эта функция действует только при вызове изнутри взаимодействия (например, из action). Вне взаимодействия эта функция не имеет эффекта.

renpy.scry()

Возвращает объект scry для текущей инструкции. Возвращает None, если инструкции не выполняются.

Объект scry сообщает Ren'Py о вещах, которые должны быть истинными в будущем относительно текущей инструкции. На данный момент у объекта scry есть следующие поля:

nvl_clear: Истинно, если инструкция nvl clear будет выполнена до следующего взаимодействия.
say: Истинно, если инструкция say будет выполнена до следующего взаимодействия.
menu_with_caption: Истинно, если инструкция menu с подписью будет выполнена до следующего взаимодействия.
who: Если инструкция say или menu-with-caption будет выполнена до следующего взаимодействия, это объект персонажа, который она будет использовать.

У объекта scry есть метод next(), который возвращает объект scry для инструкции после текущей, если только одна инструкция будет выполнена после этой. В противном случае он возвращает None.

Предупреждение

Как и другие подобные функции, возвращаемый объект предназначен для краткосрочного использования после вызова функции. Не рекомендуется включать его в данные сохранения или заставлять его участвовать в откате.

renpy.set_mouse_pos(x, y, duration=0)

Перемещает указатель мыши в место, заданное аргументами x и y. Если на устройстве нет указателя мыши или Ren'Py не может его переместить, эта функция ничего не делает.

Маловероятно, что это будет работать на платформах Linux с Wayland, Android, iOS или Web.

duration: Время в секундах, которое займет перемещение. В течение этого времени мышь может не отвечать на запросы.

renpy.set_physical_size(size): Пытается установить размер физического окна в size. Это имеет побочный эффект вывода экрана из полноэкранного режима.

renpy.shown_window(): Вызовите эту функцию, чтобы указать, что окно было показано. Это взаимодействует с инструкцией "window show", которая показывает пустое окно всякий раз, когда эта функция не была вызвана во время взаимодействия.

renpy.split_properties(properties: dict[str, Any], *prefixes: str) → list[dict[str, Any]]

Разделяет properties на несколько словарей, по одному на каждый prefix. Эта функция поочередно проверяет каждый ключ в properties на соответствие каждому префиксу. Когда префикс совпадает, он удаляется из ключа, и полученный ключ сопоставляется со значением в соответствующем словаре.

Если ни один префикс не совпадает, выбрасывается исключение. (Пустая строка, "", может быть использована как последний префикс для создания словаря, "ловящего" все остальное.)

Например, так можно разделить свойства, начинающиеся с text_, от тех, которые не начинаются:

text_properties, button_properties = renpy.split_properties(properties, "text_", "")

renpy.stop_skipping(): Останавливает пропуск, если Ren'Py в данный момент находится в режиме пропуска.

renpy.transition(trans, layer=None, always=False)

Устанавливает переход, который будет использоваться во время следующего взаимодействия.

layer: Слой, к которому применяется переход. Если None, переход применяется ко всей сцене.
always: Если false, учитывается настройка предпочтений переходов. Если true, переход выполняется всегда.

renpy.vibrate(duration): Вызывает вибрацию устройства в течение duration секунд. В настоящее время это поддерживается только на Android.