Ren'Py now supports an images directory underneath the game directory. Images found inside this directory - or in subdirectories of this directory - will be automatically defined as images in Ren'Py. This will likely render the use of the image statement obsolete in simple games.
The new AlphaMask()
displayable allows one displayable to be masked by the alpha
channel of another.
The android and iOS emulators now emulate the onscreen keyboard.
The achievement API has been changed somewhat, but only with respect for progress functions. (Which were broken in the previous releases.)
Actions that care about the current screen (like SetScreenVariable) now work when used with the hovered and unhovered properties.
The updater has improved. If an incremental download fails, Ren'Py will try downloading the complete file before giving up.
When building for Android, Ren'Py will copy the apk files in to the dists directory used by the desktop platforms.
Added the RestartStatement()
action.
Added the renpy.reset_physical_size()
and ui.screen_id()
functions.
Allowed the screen language key statement to take the activate_sound style property. This makes it easier to play a sound when a key is pressed.
Documented ui.interact()
.
Updated the Simplified Chinese and Korean translations, and the Italian template.
Added the renpy.load_image()
, renpy.load_surface()
, and
renpy.get_showing_tags()
functions.
Ren'Py is now based on Pygame_SDL2, a reimplementation of the Pygame API based on the SDL2 library. One of the largest changes in Ren'Py's history, switching to SDL2 lays the groundwork for many improvements, in this and future releases.
Ren'Py now supports the iOS platform. To develop for iOS, you will need a Macintosh computer, Xcode, and a paid membership in the iOS developer program. (An iPad or iPhone to test with is highly recommended.)
Ren'Py's iOS support includes the ability to create Xcode projects, and to update those projects with the latest version of a Ren'Py game. Xcode can be used to change project settings, and to create debug and release builds.
The iOS port supports iOS 7 and higher. Almost all of Ren'Py is supported, with the exception being that video playback is limited to fullscreen video in formats the iOS device supports.
For now, the default set of Ren'Py screens are not particularly compatible with iOS. You will need to customize your game to make it touch friendly and compliant with Apple's guidelines before submitting it to the iOS app store.
Please see the iOS documentation for more information and a copyright notice you must include as part of your app description on iOS.
Android support has been rewritten, and is now based in SDL2. This release brings Android support to parity with desktop platforms. Improvements include:
A number of issues with Android support have been fixed, including one that prevented Ren'Py from unzipping the android SDK automatically when the path to the Ren'Py install was too long.
Please see the Android documentation for more information and a copyright notice that should be included as part of your app description.
Ren'Py now ships with Python bindings for the steam API. These bindings are built as part of the Ren'Py build process, which means they will be maintained alongside Ren'Py going forwards.
For an explanation of how to use the Steam API, please contact the Ren'Py developers directly. The bindings make available:
The steam bindings will be integrated with Ren'Py as appropriate. For now, this integration consists of binding the steam achievement system to the new Ren'Py achievement API.
The launcher now has the ability to add from clauses to call statements, automatically turning:
call dayplanner
into:
call dayplanner from __call_dayplanner
From clauses, which are really labels, help Ren'Py to find the return site to use when a game is changed. This should help fix problem with games that may change greatly between releases.
When asked to package a game that is more than about 2GB in size, Ren'Py will produce a ZIP64-format archive. These archives may be less compatible that smaller zip files.
There is now a Russian translation of the tutorial game, and a Finnish translation of the launcher.
Ren'Py supports input methods (IMEs) on platforms where SDL2 makes that support available. (All platforms except for Linux.) Input methods make it possible to input complex non-ASCII text, such as Chinese, Japanese, and Korean.
Ren'Py now supports clipboard voicing, which is accessed by shift+C.
Clipboard voicing is a form of self-voicing that works by copying the text to the clipboard, where a screenreader program is likely to read it using settings preferred by the player.
Ren'Py snow supports a new form of custom text tags.
Custom text tags are applied after the text has been tokenized into tags and text. This makes it easier to write a custom text tag that manipulates text or applies multiple existing text tags to text.
The previously-existing form of custom text tag has been renamed to style text tag, and is still supported.
A high-level achievement API has been added to Ren'Py.
Ren'Py now includes support for recognizing touch gestures on Android and iOS.
It is possible to hide the editing buttons in the launcher, so they can't be used to open an absurd number of editor windows.
The developer can choose if strings should be empty when generating translations.
Three new set manipulation actions AddToSet()
, RemoveFromSet()
,
and ToggleSetMembership()
manipulate sets and lists-as-sets. (Such
as inventory lists.)
Drags (as in, drag-and-drop) now support the focus_mask style property.
The complexity of the style system has been reduced, decreasing memory usage and startup time.
The new renpy.suspend_rollback()
suspends the recording of rollback
checkpoints, while still allowing rollback to occur.
The RENPY_GL_CHECK_ERRORS controlls the logging of OpenGL/ANGLE function calls and errors.
A completion progress indicator can be toggled by typing shift-alt-P or swiping up-down-left-right-left-right.
As of this release, dictionary and set comprehensions are wrapped to support rollback.
This release adds the showif statement to screen language. The showif statement shows and hides its children based on a condition. When its children are ATL transforms, showif delivers ATL events to manage the show and hide process.
Ren'Py's image prediction mechanism now models the return stack, and can predict images through a call and return pair. Previously, a call followed by a return would block image prediction.
Ren'Py now predicts that the start label will be called from the main menu. This will help to avoid unpredicted image loads at the very start of a game.
The ATL on statement now can take a comma-separated list of event names.
The new updater.UpdateVersion()
function contacts an update server and
determines if an update is available.
The new renpy.invoke_in_thread()
function runs a function in a background
thread, and restarts the interaction when that thread finishes.
While in self-voicing mode, the {w} and {p} tags are ignored.
The Traditional Chinese and Russian translations have been updated.
Fixed a regression that could cause hiding transforms to skip time.
Fixed a bug that would cause the screen language if statement to show children from blocks with a false condition, if those child blocks were run during prediction.
Fixed an issue where SetScreenVariable and ToggleScreenVariable were declared as pure functions, but weren't. They now have been reimplemented as pure functions.
Fixed an issue where a grab could fail to transfer between interactions, leaving Ren'Py unresponsive.
The define statement can now take a store name, and the say statement
will search the character
store before searching the default store.
This means that if one uses:
define character.e = Character("Eileen")
Say statements like:
e "Hello, world."
will continue to work, even though e
has been freed up for other
purposes.
The default image cache size (set in config.image_cache_size
) has
been increased from 8 to 16 screens worth of images.
When set to True, the new crop_relative
transform property tells
a Transform to interpret float components of its crop
property
relative to the width or height of its transformed child, as appropriate.
For example, (0.5, 0.0, 0.5, 1.0) will cropout the lower-right quadrant
of the child.
When set to false, the new keyboard_focus
style property hides
buttons, bars, and imagemap hotspots from the keyboard focus mechanism.
The Mousearea screen language statement now respects the
focus_mask
style property, making it possible to have
non-rectangular mouseareas.
Ren'Py now includes functions that can be used to profile
the memory consumption of a game, including the memory consumption of
Ren'Py itself. These functions are renpy.profile_memory()
and
renpy.diff_memory()
. The new renpy.profile_rollback()
lets one more specifically see the memory consumption of the internal
rollback log.
When self-voicing mode is enabled, Ren'Py displays a notification that explains how to disable self-voicing mode.
This release fixes a subtle bug caused by incorrect analysis of for
loops in screen language screens, when the iteration variable is a
constant. (For example, when the iteration variable is define
ed
somewhere else in the game.)
This release adds Traditional Chinese translations of the launcher and template game, contributed by Civalin.
This release includes a new Placeholder()
displayable, which can be
used to display placeholder characters. Placeholders are now used when
displaying images that are not defined.
The new sv
Character-like object can be used when self-voicing is
enabled to display (and hence speak) descriptive text.
ATL transforms in screens now begin executing when first shown. Previously, ATL transforms began executing when the screen containing the ATL transform was first shown, which meant that if the transform changed over the course of screen display, a portion of the new transform would be skipped.
This release includes a German template contributed by NoJoker.
This release includes a new implementation of screen language that has the potential to be much faster than the original implementation of screen language. Where the original screen language evaluated screens from scratch at the start of each interaction, this new implementation can incrementally reuse large portions of a screen between interactions. Please see the new Screen Language Optimization documentation for information on how to maximize screen language performance.
Of special note is that screens now perform better when defined with a parameter list. Screens that do not expect parameters should be defined with an empty parameter list.
To support improved optimization, when the screen language use statement calls a screen with a parameter list, only variables in that parameter list are updated. (This is a change in previously-undocumented behavior.)
Screens now support passing properties to a displayable from within an if statement, provided the if statement is the first thing inside the displayable. For example:
text "Eileen":
if eileen_mad:
color "#fcc"
else:
color "#cfc"
now works.
As there is now a larger benefit from predicting screens, screen prediction has been improved in several ways:
show screen
and call screen
statements to predict the
screen. This is potentially dangers, as it means that if either statement
has side effects, those side effects will occur as part of screen prediction.
To mitigate this problem, both statements now take a nopredict
clause
that prevents screen prediction.renpy.start_predict_screen()
and
renpy.stop_predict_screen()
allows for manual prediction of time
images that will be used by screens, including parameterized screens.Ren'Py now supports profiling of screens, via the renpy.profile_screen()
function.
Ren'Py has been changed to make a copy of the screens being displayed before a transition occurs. This makes it possible to use a transition to show screen updates. For example, one could increase the value displayed by a bar, and then use the dissolve transition to dissolve in the new segment of bar.
Ren'Py now has a supported mechanism for manually predicting images in
cases where automatic image prediction fails. This mechanism consists
of two functions: renpy.start_predict()
starts prediction of images,
while renpy.stop_predict()
stops prediction.
Ren'Py now includes support for self-voicing, a mode in which Ren'Py will
read on-screen text to vision impaired players. To activate self-voicing,
press the v
key. For more information, please read the self-voicing
documentation.
The new alt
style property allows one to supply alternative
text that allows Ren'Py to voice imagemap components and buttons with
incomplete names.
The Ren'Py launcher now includes a large-text mode that can be accessed from the preferences page. This mode increases text size and contrast.
This version of Ren'Py includes a high-level interface that supports in-app purchasing on the Android platform. This interface currently support Google Play and the Amazon App Store.
Ren'Py supports nearest-neighbor filtering of images. This ensures that
screen pixels correspond to a single texture pixel, which is the scaling
mode preferred for use with pixel art. Nearest-neighbor mode is enabled
with the new nearest
transform property.
The new config.adjust_view_size()
callback makes it possible to
set the size of the Ren'Py viewport to something other than the size of
the window (or screen, in fullscreen mode). For example, a game can use
this callback to limit its viewport size to integer multiples of its
native size.
Voice volume is now adjustable on a per-character basis, using the
voice_tag argument to Character()
and the new VoiceVolume()
value.
Using the new config.emphasize_audio_channels
variable, Ren'Py
can emphasize audio on some channels. This is doen by lowering the
volume of non-emphasized channels when a emphasized channel is playing,
and returning the volumes to normal when no emphasized chanels are
playing. By setting this variable to [ 'voice' ]
, the voice
channel can be emphasized over music and other sounds,
To workaround a bug in Mac OS X 10.9, Ren'Py will now always open on the the primary monitor of a Macintosh.
With some limitations, non-ASCII characters can now be used as character names. Since Python code does not allow non-ASCII identifiers, such character names must be defined by the define statement, and used outside Python code.
The auto property of imagebuttons and imagemaps now can take image names as well as image filenames.
The new renpy.image_exists()
function returns true if an image has
been defined.
Gallery navigation can now be customized by customizing the gallery_nav
screen.
The new renpy.count_dialogue_blocks()
and renpy.count_seen_dialogue_blocks()
return the total number of dialogue blocks and the number of dialogue blocks that have
been seen by the current user in any game. With some caveats, these can provide an
indication of how much of the game the user has seen.
The config.autosave_on_choice
variable determines if Ren'Py will
autosave on choice, while the config.autosave_on_quit
variable
determines if Ren'Py will autosave when the game is about to end (by quit,
return, or loading a save slot).
The new events
transform property determines if events are
passed to a transform's children. This is useful for ATL transforms,
when some children should not receive events.
Save dumps (enabled by config.save_dump
) are performed before the
save occurs, making them far more useful for debugging pickling problems.
When show_ arguments are past to an NVLCharacter()
, the show_ prefix
is stripped and those arguments are passed to the nvl
screen.
This release add an Italian translation of the launcher and template game, contributed by Oshi-Shinobu.
This release adds a Portuguese translation of the template game, contributed by Mrstalker.
This release adds a Simplified Chinese translation of the launcher, contributed by Huanxuantian.
This release includes a number of Android changes:
This release includes a fix to an audio-video sync issue that affected the Windows, Mac OS X, and Linux platforms.
This release adds a German translation of the launcher, contributed by Marcel.
This release adds a Korean translation of the launcher and template game, contributed by Baekansi.
This release includes a workaround for an issue that could prevent the launcher from starting on certain Mac OS X computers.
This release features an Arabic translation of the launcher and template game, contributed by Renoa.
The Japanese and Spanish translations have been updated.
The traceback system has been changed to generally report script statements, rather than the functions Ren'Py uses to implement those statements.
The renpy.pause()
function now only sets a checkpoint (allowing rollback)
if the delay time is 0. This prevents rollback from being blocked by short
pauses.
The new renpy.queue_event()
function provides a way to queue Ren'Py
events from user-written interface code. (For example, it could be used to
listen to commands on a serial port that's connected to a custom
controller.)
If set, RENPY_SKIP_MAIN_MENU and RENPY_SKIP_SPLASHSCREEN environment variables cause Ren'Py to skip the main menu and splashscreen, respectively.
The RENPY_TIMEWARP environment variable makes it possible to speedup and slow down time.
An experimental new autoreload system can be accessed by setting
config.autoreload
to True, then pressing shift+R to toggle
automatic reloading.
A regression in 6.17.4 caused a major memory leak on shift+R. This has been fixed. Several other problems with shift+R have also been fixed.
An issue preventing transitions from working properly inside a restarted ATL transform has been fixed.
The --warp was documented incorrectly, and had stopped working. It's been repaired, and its documentation has been improved.
This release contains a complete rewrite of shift+R reloading.
The rewrite was necessary to eliminate several major memory leaks that were triggered by reloading.
Ren'Py has been updated to use the newest (at the time of release) versions of the Android SDK and Ant. This should fix build problems caused by the use of older versions.
Ren'Py now recognizes and supports the Amazon Fire TV device. When a Fire TV is detected, the "firetv" screen variant is selected. To support pushing games to this device, Ren'Py now supports connecting to Android devices via the Remote ADB protocol.
Fixed a problem that occurred when an interaction containing a MoveTransition was restarted.
Added support for imagemaps that are larger than the screen. This allows an imagemap to be placed inside a viewport.
It is now possible to select the layer used by the say, choice, and nvl
choice screen. Please see config.say_layer
, config.choice_layer
,
and config.nvl_layer
statements.
The prediction of window and bar images has been improved.
The style system, which makes it possible to configure the look of displayables, has been rewritten from scratch. The new code reduces the amount of time it takes to create a new style to a small fraction of the previous time. Since every displayable creates an associated style, this has the potential to lead to a substantial performance improvement.
This release also introduced a new style statement that can be used to define styles, in place of python code. (Of course, the older form remains fully supported.) Lengthy and redundant code like:
init python:
style.quick_button_text.set_parent('default')
style.quick_button_text.size = 12
style.quick_button_text.idle_color = "#8888"
style.quick_button_text.hover_color = "#ccc"
can be replaced with:
style quick_button_text is default:
size 12
idle_color "#8888"
hover_color "#ccc"
Finally, the style inspector (accessed through shift+I) has been rewritten.
In addition to the new style statement, there are four other syntax changes:
The definition of a simple expression has been expanded. Simple expressions (which are used in ATL and the screen language, among other places) now encompass all Python expressions that do not include lambda or the ternary (... if ... else ...) operator.
This means that code like:
show logo:
xpos 800 / 2
is now legal. Previously, the expression had to be parenthesized.
The new show layer
statement allows one to apply a transform
or ATL transform to an entire layer, using syntax like:
show layer master at flip
or:
show layer master:
xalign 0.5 yalign 0.5 rotate 180
The new window auto
statement makes it possible for Ren'Py to
automatically show and hide the dialogue window. By default, it is
shown before say
statements, and hidden before scene
statements,
but this can be customized.
The init statement has been extended so it can be combined with other statements. It's now possible to write "init 1 image = ...", "init -2 define name = ..." and so on.
This release adds French and Russian template games and translations of the launcher.
It is no longer necessary to download RAPT (the Ren'Py Android Packaging Tool) separately from Ren'Py. As of this release, RAPT will be downloaded by the Ren'Py launcher when an Android build is requested, and will be updated by the Ren'Py updater.
Buttons may now have an alternate action that is triggered by longpress on Android and right-click on desktop computers.
This release fixes a bug in which Ren'Py would not save persistent data (including preferences) before being terminated by the Android system, and a regression that broke compatibility with some Android 2.3 systems.
There are two new preferences accessible through the Preferences()
function:
Neither of these is exposed as part of the default preferences screen, but both can be added by interested developers.
There is one changed preference:
ShowMenu()
can now pass arguments to the screen it displays.
The input displayable now takes a pixel_width property, that limits the size of the input field it a certain number of pixels.
The FileCurrentScreenshot()
function
The new xsize
, ysize
, and xysize
style
properties make it possible to directly set the size of a displayable.
The focus_mask
style property can now take as an argument a callable
that returns true when a displayable should be focused. If such a callable
can be written, it may be much faster than the current method of determining
pixel opacity.
Viewport now respects the xfill and yfill properties. The default viewport style sets these to true. Setting them to False will cause the viewport to shrink to fit its contents when those contents do not fill the entire viewport.
The new renpy.get_image_bounds()
function retrieves the bounding box
of an image that is being displayed, after all Transforms have been applied
to it.
The new renpy.retain_after_load()
can be used to retain data updated
by a screen after the game is loaded.
The new xsize
, ysize
, and xysize
style
properties make it possible to directly set the size of resizable
displayables.
Prediction of images with partial attributes and side images used in dialogue has been improved. Prediction of creator-defined statements now works as documented.
This release adds a Spanish translation of the launcher and the template game.
This release adds the new renpy.get_mouse_pos()
function, which
retrieves the mouse position if a mouse is supported.
Android support has now been integrated into the Ren'Py launcher. While for size reasons RAPT is still a separate download, once RAPT has been placed inside the Ren'Py directory, the launcher will allow you to:
The launcher can now launch Ren'Py in modes that simulate Android phones, tablets, and television-based consoles.
Ren'Py includes support for television-based Android consoles, such as the OUYA. It includes support for detecting the OUYA specifically, and choosing a variant as appropriate.
This release adds some video playback support to the Android port. While limited to full-screen video and codecs that the Android platform supports (which unfortunately have little overlap with desktop Ren'Py), this may be enough to enable cutscene movies.
Ren'Py now includes a new set of screen variants, with "large", "medium", and "small" reflecting the visual size of devices (televisions are considered to be small because they're far away), while "touch", "tv", and "pc" reflect the input devices involved.
Android now supports displaying vertical text.
The low-level load/save API has been overhauled. It's now possible to
access save slot information directly, instead of having to scan all save
slots to find the one you want. New functions include renpy.list_slots()
,
renpy.newest_slot()
, renpy.slot_mtime()
,
renpy.slot_json()
, and renpy.slot_screenshot()
.
At a higher level, there is a new FileNewest()
function that's
true for the newest save slot. FilePageNext()
and
FilePagePrevious()
now support a wrap argument that causes them
to wrap around a defined number of screens.
There is now support for adding arbitrary JSON information to save files. This allows per-save information (like the path you're on in a VN, date and amount of money in a sim, or party composition in an RPG) to be accessed from the save and load screens.
JSON information is created by config.save_json_callbacks
,
and can be accessed through the low-level renpy.slot_json()
or
high-level FileJson()
functions.
When possible, Ren'Py now stores save files with the game, as well as in a user-global save directory. This means that if a Ren'Py game is placed on a USB drive or shared on a network, the saves will be available on multiple computers. (When save files are available in both places, the newest file wins.)
When a save file on a network share is updated, Ren'Py will automatically rescan the contents of that file, and restart the current interaction. (This will update the save and load screens, making the file available to be loaded.)
Ren'Py will no longer auto-save while at the main menu.
Persistent data is also stored in both locations. When the persistent
data is not identical, it will be merged. By default, the most recently
updated value for each field will be used. In some cases (for example, a set
of endings the player has reached), this is not the correct behavior. The
new renpy.register_persistent()
can be used to register different
merge behavior.
This release adds support for playing voice without having to fill the script with voice statements. This support consists of two new pieces of functionality:
config.auto_voice
variable is used to give a filename pattern
that is formatted with the unique identifier. If a file with that filename
exists, and no other voice file is being played, that file is used as the
voice.There are also several new voice-related preferences. The "voice sustain" preference determines if voice is sustained through multiple interactions. The "wait for voice" preference determines if auto-forward mode waits for the voice to finish before advancing.
The image gallery now can display a navigation overlay with next, previous, slide show, and return buttons. The creator can choose if these buttons display the images associated with a single button, or advance between multiple buttons.
The Music Room includes the ability to play a random track, and to determine if the tracks are shuffled, looped, or if play is confined to a single selected track.
Ren'Py now renders portions of font characters that leave the character bounding box. This prevents text (especially hinted and anti-aliased text) from being cut off, but may lead to apparent placement problems for fonts with very inaccurate bounding boxes.
The Ren'Py launcher has been translated into Japanese. The language used by the launcher can be switched from the preferences screen.
There is now a Japanese language template game, which defaults to a Japanese font and has a translated interface.
Much of the documentation has been translated to Japanese. The Japanese translation can be found at:
The Ren'Py documentation has been improved. The following pages have been added or migrated from the old wiki-based documentation.
Many other documentation pages have been improved and edited.
The default quick menu now includes rollback and fast skip functionality. (This functionality is contained in the template screens.rpy, and may need to be copied into your game.)
The default yes_no screen now answers no when the user right-clicks. (This functionality is contained in the template screens.rpy, and may need to be copied into your game.)
The fast skipping function now stops when it visits seen text.
The build.destination
variable can be used to select the directory
in which Ren'Py places files when building a distribution.
There is a new NullAction that can be used when one wants a button to be sensitive to hover and unhover, but not performing a useful action on click.
ConditionSwitch is now much faster.
Ren'Py will deal with files with insane timestamps by giving them the current time.
This release includes many bugfixes. Some of the more important are:
This release includes improvements for the Android platform:
The GL2 shaders Ren'Py uses have been simplified in the (usual) case where no clipping is occurring. This leads to a noticeable speed improvement on Android, and potentially other platforms as well.
An issue with Drag-and-drop has been fixed. Thanks go to Kinsman for contributing this fixe.
The Skip()
action now triggers the skip indicator. It also
supports a new fast parameter, which causes skipping to the
next menu.
This release includes various minor changes to improve compatibility with very old Ren'Py games. (It now runs the Ren'Py 5 demo.)
This release adds two new features:
additive
transform property in an ATL transform or use of the
Transform()
class. Additive blending will not work if the software
renderer is in use, and it's up to creators to deal with that issue.Flatten()
displayable combines multiple textures into
a single texture. This can be used to prevent incorrect behavior
when a displayable containing multiple overlapping textures (like a
LiveComposite()
is shown with an alpha
between 0 and 1.It also fixes the following issues:
This release fixes a compile problem that prevented Ren'Py 6.14.x and Ren'Py 6.15.0-3 from running on most 64-bit Linux systems.
Image prediction has become more fine-grained, and can take place while the screen is animating.
The new build.exclude_empty_directories
determines if empty directories
are include or excluded from the distribution. It defaults to true,
previously the default was platform-dependant.
Ren'Py now includes a comprehensive translation framework. This framework includes support for using a single language selection to change dialogue, menus and other interface text, images and files, styles and styles.
The dialogue translation support allows lines of dialogue to be split and combined at the translator's discretion. As most Ren'Py statements are allowed inside the new translation blocks, it's possible to use logic (like conditions) to tailor the translations to your language.
The launcher includes a new "Generate Translations" button, which - as part of a sanctioned translation where the full script is present - will generate empty translation files for a new language.
Ren'Py 6.15 includes multiple changes to better support the Japanese language.
The tutorial game has been translated to Japanese, with the language being selectable from the preferences menu.
The tutorial was translated by Koichi Akabe.
Support for vertical writing has been added to Ren'Py. Consisting of the
vertical
style property for text, and the new
box_reverse
property on hboxes, this support makes it possible
to display dialogue, menus, and other text in a vertical orientation.
Vertical text support was written by Koichi Akabe.
The line-breaking algorithm has been updated to match Unicode 6.2. In addition, three new "languages" have been added. The new "japanese-strict", "japanese-normal", and "japanese-loose" languages (based on the line-break options in the CSS3 Text module) allow greater control of how Ren'Py breaks lines with small kana and other special characters.
Linebreaking can be further tailored using the new
renpy.language_tailor()
function, which can change the linebreaking
class of a character.
The new debug console makes it possible to interactively run Ren'Py script and
Python statements, and immediately see the results. The console is available
in developer mode or when config.console
is True, and can be accessed
by pressing shift+O.
The console can be used to:
The console was originally written by Shiz, C, and delta.
Screens now take named parameters, similar to the way that labels and transforms take named parameters. It's now possible to write:
screen top_text(s, size=36):
text s xalign 0.5 size size
and:
show screen top_text("It works!")
Ren'Py now includes support for replaying scenes. A scene replay can be invoked from anywhere in Ren'Py (for example, from a main menu or game menus screen, even when the game has started). When the replay ends, Ren'Py will return to the location the replay was invoked from, even if that location is in a screen or in python code. Rollback works inside a replay, but saving and loading is disabled.
The Replay()
action begins a replay. The renpy.end_replay()
ends a
replay if one is in progress, and is ignored otherwise.
There have been several improvements to the voice playback system. The new
config.voice_filename_format
variable makes it possible to use only
part of the filename in a voice statement. The new voice_tag parameter to
Character()
, in conjunction with the SetVoiceMute()
and
ToggleVoiceMute()
actions, makes it possible to selectively mute
particular characters' voices. The new VoiceReplay()
action makes it
possible to replay the current voice.
There were a few launcher improvements in this release.
The Macintosh version of Ren'Py now requires a 64-bit capable processor, and Mac OS X 10.6 or newer.
The file layout of Ren'Py games has been somewhat altered. With the exception of small launcher programs, all platform-dependent binaries are under the lib/ directory. Ren'Py itself has now been placed in the renpy/ directory. The common/ directory has been moved to renpy/common/, as it's considered an integral part of Ren'Py.
Ren'Py now uses renamed but otherwise unmodified python binaries on all desktop platforms. (Previously, it used platform-specific binaries.) Portions of the library are shared between the desktop builds.
A running Ren'Py process on Linux will now be named after the game, rather than having python as a name.
config.key_repeat
.config.enter_yesno_transition
and
config.exit_yesno_transition
variables make it possible to define a
transition that is run when yes/no prompts appear and disappear,
respectively.transform_anchor
transform property makes the anchor the
point around which a transform is scaled and rotated. (For example, it's
now possible to rotate around the bottom-right corner of an image, rather
than just its center.)box_reverse
and order_reverse
style
properties allow the user to control the order in which children of vbox
and hboxes are placed and drawn, respectively.child
style property of buttons is now exposed to the
screen language.config.enter_yesno_transition
and
config.exit_yesno_transition
variables allow a creator to supply
transitions that are used upon entering and exiting yes/no prompts.Among others, the following bugs were fixed:
renpy.loadable()
failed to search for files inside
android packages.renpy.loadable()
now works with Android
assets.renpy.call()
a label that doesn't take
parameters.The Ren'Py launcher has been rewritten. Some of the improvements are:
A new visual design by Doomfest of the Dischan visual novel team.
The launcher now includes direct access to open the script and game directories, and common script files.
The launcher includes Script Navigation support. Clicking the name of a label, define, transform, screen, or callable will open the editor to the location where that name is defined.
Script navigation also provides access to individual script files.
The launcher now supports one-click project building. Instead of using multiple steps to build a project, a single click will now cause the launcher to:
The launcher can now use the Ren'Py updater to update Ren'Py, and to download editors.
For most users, Ren'Py recommends the use of the Editra editor. We have developed an Editra plugin that communicates with the Ren'Py launcher and supports the editing of Ren'Py script.
While still in beta, Editra is a fast and light editor with good code editing support. Editra also includes a spell-checker that can be enabled, and applies to dialogue and other strings.
If Editra is selected by the user, and it is not installed, Ren'Py will automatically download it.
The jEdit editor remains supported, and is preferred for use with languages (like Chinese, Japanese, and Korean) that Editra doesn't support fully. If selected, Ren'Py will download jEdit automatically.
Ren'Py also supports editing files through system-specific file associations. (This support will not send the cursor to the correct line, however.)
Ren'Py includes an updater that can update Ren'Py and individual Ren'Py games by downloading changes from a properly-configured web server with a small number of update files uploaded to it.
The updater uses zsync to download the minimal set of changes between the local files on disk and the files stored on the server. A single set of files on the server supports updating from all prior versions of a project.
Ren'Py includes a default updater interface that can be further configured by interested users.
This release changes the behavior of transforms to make them more correct and easier to use.
The xzoom and yzoom properties are now applied before, rotation. This means that the shape of the image will remain consistent as the image is rotated. Previously, the image to change shape as it was rotated.
The xzoom and yzoom properties may now be negative, with negative zoom values causing the images to be flipped. The positioning code now takes this into account, and positions a flipped image properly.
Thanks to Edwin for contributing these changes.
text\_
. These properties have the
text_ prefix stripped, and are then passed to the internal text displayable.MoveTransition()
has been rewritten. The new version now uses
transforms to control the positioning of entering and leaving images, and
can interpolate between the locations of moving images.The new renpy.fix_rollback()
function allows the game to fix
choices, even if they are made in rollback mode. The user can roll back and
roll forward, but is restricted to making the choices he made the first
time through the game.
Thanks to Edwin for contributing fix_rollback.
Rolling forward now works through a jump out of a call screen
statement.
Ren'Py's video playback support has been partially rewritten to improve robustness, speed, and framerate stability. These improvements should reduce the number of frame drops Ren'Py performs, and should also prevent Ren'Py from locking up if too many frames are dropped.
Ren'Py now supports the WebM video format.
When config.developer
is true, Ren'Py keeps an internal log of image
loads.
This log can be access by showing the _image_load_log screen. This screen displays the name of an image file for a few seconds after that image has been loaded. The name is in white if the image was loaded by the image predictor, and pink if Ren'Py was unable to predict the image.
Two screen functions have been added, and two screen actions have been changed:
FileUsedSlots()
function returns a list of used file slots
on the current page.FileCurrentPage()
function returns the name of the current
page.FileSave()
and FileAction()
actions have been modified so
that if the slot name is None, an unused slot based on the current time is
used.Taken together, these changes make it possible to create a list of save slots where the user is able to add new slots to the list.
Ren'Py now supports multiple stores - multiple namespaces in which python code can be run. Variables in these stores are saved, loaded, and rolled-back in the same way that variables in the default store are.
Stores are accessed by supplying an in-clause to a python block. For example:
init python in stats:
def reset():
"""
Code to reset the statistics.
"""
User-created stores are placed into the "store" package, with the default store being the package itself. Names can be imported between packages.:
init python:
from store.stats import reset
init python in stats:
from store import ToggleField
Note that stores do not affect the order in which init python blocks are run. A name must be defined in a block before the one that imports that name.
Linux support has been changed.
Many libraries that Ren'Py depends on have been updated. Some of the changes that have occurred are:
The renpy.call()
function allows - with major and important caveats -
a call to a Ren'Py label to begin from inside python code. Such a call
immediately terminates the current statement.
When an action is expected, nested lists of actions can be given. The lists are flattened and the action executed.
Added the OpenURL()
action, which opens a URL in a web browser.
Added the config.gl_resize
variable, which determines if the user
can resize OpenGL windows.
Ren'Py's handling of command line arguments has been rewritten. Most notably, lint is now invoked with the:
renpy.sh <gamename> lint
command. (Which also works with renpy.exe.)
Ren'Py can now dump information about the game to a json file when starting up. The information dumped can assist other tools in providing launcher-like code navigation.
The little-used remote control feature has been removed from Ren'Py.
The config.gl_resize
variable now controls resizing of a game
running in GL mode.
Documentation fixes (by SleepKirby and others).
The NVL-Mode tutorial has been ported to Sphinx (by Apricotorange).
Ren'Py now defaults to reporting errors with sound and music files when config.developer is True.
The new RAPT tool makes it far easier to package a Ren'Py game for Android. It can semi-automatically set up an Android build environment on your system, build a package, and install that package on your Android device.
To fix some editor-related problems, backported the 6.14 editor system. This changes how editors are configured. Please see Text Editor Integration for a description of the new system.
The new config.save_dump
variable causes Ren'Py to write out
save_dump.txt each time it saves. This file describes the contents of the
save, making it possible to figure out what's causing an overly large save
file.
Worked around a bug in Mesa that can cause crashes on certain Linux systems.
Fixed the following bugs in Ren'Py.
Side images can now be limited to showing a single character, or only showing
characters that are not on the screen. See config.side_image_tag
and
config.side_image_only_not_showing
.
Added config.python_callbacks
, a list of python functions that are
called at the end of each python block.
Ren'Py now tests the video card it is running on for functionality. If it can't draw textured rectangles to the screen, it will proceed to a different renderer.
Old-style string interpolation is now enabled by default, alongside new-style string interpolation.
Ren'Py is now compatible with libpng 1.5. Thanks to James Broadhead for the patch.
Fixed the following bugs:
Text display has been rewritten from scratch. In addition to supporting many new features, the new implementation of Text is much faster at text layout and display, and contains much cleaner code.
Some of the new features that are now supported by the text display system are:
Interpolation of variables enclosed in square brackets. It's now possible to write code like:
"You scored [score] out of a possible [max_score] points."
The new string interpolation takes place on all text that is displayed, rather than just say and menu statements. When used as part of a screen, interpolation has access to screen-local variables.
PEP 3101-style string formatting is supported, which means that this syntax can be used to display fields and items, as well as variables.
Kerning support was added, both as the kerning
style property
and the k
text tag.
Support for ruby text (also known as furigana), via the rt
and
rb
text tags, and the ruby_style
style property.
The new space
and vspace
text tags make it easy to whitespace
into the text.
The new cps
text tag controls the speed of text display.
By default, Ren'Py uses the unicode linebreaking algorithm to find points
at which a line can be broken. This algorithm should correctly break lines
that contain a mix of western and eastern languages. Since that algorithm
is incorrect on some Korean texts, Ren'Py also implements a
korean-with-spaces variant, that only breaks runs of Korean text at
whitespace. These algorithms can be selected by the language
style property.
Ren'Py now uses the Knuth-Plass linebreaking algorithm to choose the
points at which it actually splits lines. This algorithm attempts to
minimize the unevenness of all lines except the last. Ren'Py also supports
a nobreak mode, which allows one to create a Text larger than the screen
without it being automatically wrapped. These can be selected using the
layout
style property.
The new newline_indent
style property determines if Ren'Py adds
indentation after a newline in text.
The new line_leading
style property inserts space above a line
of text. (Ruby text can be placed into this space.)
Text can be automatically translated before it is displayed. (This support will be improved in a future major release.)
On Windows systems that have the February 2010 DirectX update installed, Ren'Py will use DirectX via the ANGLE adaptation layer, if OpenGL 2.0 or later is not found. The ANGLE layer is used by popular web browsers such as Firefox and Google Chrome. This allows hardware rendering to be used on netbooks, where drivers often support DirectX far better than OpenGL.
At startup, Ren'Py will test the graphics capabilities of the computer it is running on. If the software render is being used, or the game renders at an unacceptably slow speed, Ren'Py will display a warning message to the user. The warning message includes a link to a page on renpy.org that explains how to update the graphics drivers.
This version of Ren'Py will only use the software renderer if both DirectX and OpenGL are incapable of rendering Ren'Py games. Screen-scaling in the software renderer has been replaced by a simpler but slower version.
Ren'Py now includes a style preference system. This system allows styles to be changed after the init phase has finished. These changes are saved with the persistent data. Among other things, style preferences allow a game to offer the user the option to change the font, size, and color of dialogue text.
Support has been added for screen-based image galleries and music rooms. This support consists of a classes that provides actions that make it easy to present the user with graphics and music. The creator is responsible for creating screens that use the supplied actions.
The default screens.rpy file, used when a new game is created, contains support for a "quick menu". This menu adds buttons to screens that allow the user to quick save, quick load, save, toggle skipping, toggle auto-forward mode, and access the preferences menu.
Ren'Py includes 5 new themes, and a number of new color schemes.
Several new actions have been added. The SelectedIf()
action allows
the creator to control if a button is displayed in the selected state. The
SetMixer()
action allows a mixer to be set to a specific value. The
Rollback()
and RollForward()
actions allow the creator to bind
rollback to buttons.
The behavior of the xfill and yfill style properties was accidentally changed in the 6.12 series. It has been returned to the historical behavior.
The Dissolve()
and ImageDissolve()
transitions now take a
time_warp parameter.
The Frame()
displayable now allows the user to specify the left,
top, right, and bottom borders independently.
The caret
style property allows the user to customize the caret
of an input widget.
The renpy.displayable()
function has been exposed to the user.
Timers can now take a list of actions, rather than just a single callable.
Three transforms were added to the default library: top
,
topleft
, and topright
.
Ren'Py can now load files (including images, music, and fonts) from an Android package.
User-defined statements can now take a block, which the statement is responsible for parsing.
Wrote documentation for:
Several indexes were added to the documentation, and the style was updated.
Ren'Py now uses the libjpeg-turbo library, for faster jpeg loading. Ren'Py now uses libav 0.7.1, for improved compatibility with movie formats.
Removed support for the iLiad platform.
PowerPC support has been removed from the main Ren'Py distribution. It's available as a download from the Ren'Py web site.
Thanks to Aleema for contributing the new themes and color schemes.
This release contains the following changes:
Thanks to David Gowers and zhangning for contributing patches to this release.
The process of showing images is now attribute-based. Image names now consist of a tag, and zero or more attributes. When showing an image, the order of attributes is no longer important - it's now possible to define an image using one set of attributes, and show it using those attributes in a different order.
Attributes are also "sticky". This means that we attempt to preserve as many attributes as possible when showing a new image.
For example, say we had the following images:
image eileen beach happy = "eileen_beach_happy.png"
image eileen beach woozy = "eileen_beach_woozy.png"
We can now show the first image using the command:
show eileen happy beach
Since the order of attributes no longer matters, this will show the "eileen beach happy" image. If we follow this with the show statement:
show eileen woozy
the image "eileen beach woozy" will be shown. (Assuming no other images exist. If the image "eileen happy woozy" existed, an ambiguity error would occur.)
When an image tag is shown without any attributes, then the current attributes are retained. Now, one can write:
show eileen at right
to display Eileen on the right side of the screen, without changing the attributes supplied to an image.
Say Attributes. Image attributes can be updated as part of a say statement. A character can be given an image argument, giving the name of an image that character is linked to. As part of the say statement, image attributes can be given before the dialogue string. These attributes are given to the linked image.
For example, if we define a character using the code:
define e = Character('Eileen', image="eileen")
the code:
e woozy "I think I'm getting too much sun."
is equivalent to:
show eileen woozy
e "I think I'm getting too much sun."
whenever an image with the tag eileen is being shown.
Side Image. This release features a new implementation of Side Images, which allows side images to be defined like other images, and allows side images to be integrated with screens easily.
Sticky Transforms. Finally, showing an image without providing a transform or ATL block will now continue the previous transform that an image with that tag was using. Previously, it caused those transforms to stop.
Ren'Py now has a new exception handing framework. Instead of always crashing when an error occurs, Ren'Py will now display the error message on the screen, and give the user the following choices, as appropriate to the situation:
When an editor is defined, Ren'Py will allow the user to click on a filename and line number to open that line in the editor.
The framework is used to handle exceptions and parse errors.
When in OpenGL mode, Ren'Py now remembers the window size between sessions.
(This can be disabled using config.save_physical_size
, and it may
make sense to do so if your game is using the pre-screen preferences system.)
Choosing the "Window" display preference now resizes the window to 100% of
normal size.
Added the xcenter
and ycenter
position and transform
properties. These set the position of the center of a displayable.
The renpy.vibrate()
function allows Ren'Py to ask Android devices to
vibrate.
The hyperlink style, callback, and focus functions have now been moved to the
hyperlink_functions
style property. This allows the functions to
be changed on a per-style basis.
Indentation errors are now reported on the indented line, and not the line preceding the erroneous indentation.
Added the SetScreenVariable()
and ToggleScreenVariable()
actions.
These allow screen-local variables to be changed.
Ren'Py now attempts to elide personal information from filenames. Where possible, filenames are reported relative to the base or Ren'Py base directories, rather than the root of the filesystem.
The new box_wrap
style property allows hboxes and vboxes to
automatically wrap when they reach the edge of their enclosing area.
Actions now can have an Action.unhovered()
method. This method is called
when an action supplied as a hovered parameter loses focus.
Added the Tooltip
class, which makes it easier to define tooltips as
part of a screen.
Added config.debug_text_overflow
, which controls the logging of cases
where text exceeds its allocated area.
Ren'Py no longer attempts to adjust the system level mixer controls, which means that it's no longer possible to raise the volume from within Ren'Py. Controlling the system volume exhibited bugs on all three platforms, including hard-to-predict volume changes that affect other applications.
Along with the new features, transitions have been documented in the new manual.
Archives are now automatically detected in asciibetical order. See the
documentation for config.archives
for more details.
Bug fixes:
Ren'Py now supports the Android platform. This includes support for a large fraction of Ren'Py's functionality, although we were unable to add support for imagedissolves and movie playback. It should be possible to package a Ren'Py game and distribute it through the Android market.
Android support required several changes in Ren'Py:
Added the SpriteManager displayable. This provides a high-performance way of drawing many similar sprites to the screen. This can scale to hundreds of particles, provided those particles are mostly similar to each other.
Added the Mousearea widget. A mousearea allows hovered and unhovered callbacks to occur when the mouse enters and leaves an area of the screen. Since it doesn't participate in the focus system, a mousearea can include buttons and bars.
Added Drag and Drop widgets and displayables. The drag and drop system can support:
Ren'Py is now better at predicting image usage. Along with predicting images used by normal gameplay, it now attempts to predict images that are used by screens one click away from the user. For example, during normal gameplay, it will predict images on the first screen of the game menu. While at the game menu, it will predict the other screens of the game menu, and also the images the user will see when returning to the main menu. This prediction is automatic, but only occurs when using screens.
Screens may be invoked at any time, in order to allow for image prediction, unless they have a predict property of False. This means that displaying a screen should not have side effects. (Most screens only have side effects when a button is clicked or a bar changed - that's still fine.)
Ren'Py now supports hotspot caching for screen language imagemaps. When
config.developer
is true, Ren'Py will write a PNG file in the
game/cache/ directory containing image data for each of the hotspots in the
imagemap. If the cache file exists (regardless of the config.developer
setting) it will be loaded instead of loading the hotspot images. As the
cache file is often much smaller than the size of the hotspot images, it will
load faster and reduce image cache pressure, improving game performance. This
behavior only applies to screen language imagemaps, and can be disabled with
config.imagemap_cache
.
This should remove most of the need for renpy.cache_pin()
. While not an
error, the use of cache pinning can cause unnecessary memory usage when the
wrong image is loaded.
Ren'Py now ships with a default set of screens, which are used by the demo and installed by default when a new game is created. You can find them in template/game/screens.rpy, and they can be used by copying that file into your project. These screens are not 100% compatible with the previous layout system - for example, some styles have changed. That's why games must opt-in to them.
The definition of the items parameter of the Choice and NVL screens has changed, and games will need to be updated to work with the new version.
Character arguments beginning with show_
are passed to the
Say screen. This allows things like show_side_image and
show_two_window to work with screens. The screens we ship support these
options.
The new config.imagemap_auto_function
variable allows the game-maker to
control the interpretation of the auto
property of imagemaps and
imagebuttons.
The imagemap caching behavior described above applies only to screens.
The FilePageName()
and FileSlotName()
functions make it easier to
name slots
Ren'Py 6.12 includes a number of other improvements:
config.screenshot_callback
is called. The
default implementation of this function notifies the user of the location
of the screenshot.Solid()
and Frame()
displayables are now tiny and no
longer take up (much) space in the image cache.Render.canvas()
from working with the
OpenGL renderer.This release includes four new themes, generously contributed by Aleema. You can see and change to these new themes by clicking the "Choose Theme" button in the launcher.
The jEdit text editor included with Ren'Py has been updated to version 4.3.2, a supported version that should be able to run most plugins.
The maximum default physical size of the Ren'Py window is now 102 pixels smaller than the height of the screen. This should prevent Ren'Py from creating windows that can't be resized since they are much bigger than the screen.
Buttons now only pass key events to their children when they are focused. This allows a screen language key statement to be used as the child of a button, and only activate when the button is focused.
MoveTransition was rewritten to correctly deal with cases in which images changed their order. This may lead to differences in behavior from the old version, where the ordering was undefined.
Fixed launchpad bug 647686, a regression that prevented sounds from looping properly.
Fixed launchpad bug 661983, which caused insensitive hotspots to default to the idle, rather than ground, image when no insensitive image was supplied.
Fixed launchpad bug 647324, where ImageDissolves are rendered as if specified with alpha=True whether or not alpha=True was set.
Fixed a problem that caused the game to start when picking "No" after clicking the (window-level) quit button.
Fixed a problem that prevented AnimatedValue from functioning properly when delay was not 1.0. Thanks to Scout for the fix.
Fixed a problem that caused movies to display incorrectly when the screen was scaled using OpenGL scaling.
Add the AlphaBlend()
displayable and the AlphaDissolve()
transition. These take two displayables, and use the alpha channel of a third
displayable to blend them together. (The third displayable is often an
animation, allowing the effect to change over time.)
The new Modes system allows one to invoke callbacks when switching from one type of interaction to another. This can be used, for example, to automatically hide the window before transitions.
Imagemaps created using the screen language now only have a size equal to that of their ground image. (Previously, they took up the entire screen.) This change makes it easier to position an imagemap at a different location on screen, such as the bottom.
Imagemaps now take an alpha argument. If true (the default), hotspots are only focused if the mouse is over a non-transparent part of the idle or hover image. If set to false, the hotspot is focused whenever the mouse is within its boundaries.
Added the renpy.focus_coordinates()
function, which returns the
coordinates of the currently focused displayable, when possible.
The new renpy.notify()
function and Notify()
action make it simple
to flash small status messages on the screen, such as might be used to notify
the user of a completed quicksave or screenshot.
The new HideInterface()
action allows the interface to temporarily be
hidden, as a screen language action.
The developer menu now includes a command that will list all the files in the game directory.
The urllib and urllib2 modules from the Python standard library are now distributed as part of Ren'Py. These modules allow data to be retrieved from web servers.
The launcher now includes an experimental updater, that makes it easier to update to the latest pre-release. Hitting shift+U at the launcher's main screen will cause Ren'Py to be updated.
MoveTransition()
now respects the xoffset and yoffset parameters.
Fixed several bugs with screen-language imagemaps.
Fixed a bug (#626303) that was caused by an incorrect texture unit check. Thanks to tmrwiz for the fix.
Transforms no longer cause a divide by zero exception when the zoom, xzoom, or yzoom properties are 0.
Clockwise and counterclockwise revolution in transforms now works.
Fixed a bug with scaling, that occurred when switching between the scaled software and GL renderers.
Hidden screens are no longer considered when assigning default focus.
FieldValues with max_is_zero set to True now work properly. Thanks to SleepKirby for the fix.
Ren'Py will now take advantage of a computer's OpenGL hardware acceleration, if supported. This OpenGL support has several user-visible changes:
Software rendering is still supported, and Ren'Py will automatically fall back to software rendering if it detects an improperly configured video card.
You can test that Ren'Py is in OpenGL mode by attempting to resize the window. If it's resizable, it's OpenGL, otherwise, software rendering is being used.
This release introduces a new screen system, which allows one to use the new screen language to declaratively specify portions of the user interface. The screen language supersedes layouts, overlay functions, imagemaps, and most other means of customizing the out-of-game menus and the in-game screens.
The previous way of customizing the behavior of the game menu, the layout system, had problems, especially when using imagemap layouts. Screens were single-purpose, and it would be difficult to (for example) load a quick-save game from the main menu, without extensive Python code.
The screen system addresses this by providing a pool of functionality, in the form of Actions and BarValues. This makes it possible to pick and choose functionality, and add it to screens as is deemed necessary.
If a transform does not define one of the position properties
xpos
, ypos
, xanchor
, or
yanchor
, that property will be taken from the transform's child,
if the defines that property.
This makes it possible to have one transform control a displayable's
vertical motion, and the other control the horizontal. But this is
incompatible with previous behavior, and so can be disabled with the
config.transform_uses_child_position
variable.
The new config.default_transform variable allows a transform to specify the initial transform properties of an image that does not have a more specific transform applied to it. Its default value is center, a transform that shows the image at the center-bottom of the screen.
This can lead to a behavior change. When an image is shown, and then shown transforms, the transform will be initialized to the bottom center of the screen, not the top-left. The reset transform can be used to reset the position to the top-left.
Transform (and ui.transform) have been changed so that their arguments can now be prefixed with a style prefix. One can write ui.transform(idle_rotate=30, hover_rotate=90) and have it work.
Added the rotate_pad transform property, which controls how Transform pads rotated displayables. When set to False, _not_ the default, it's now possible to rotate a (100, 50) displayable by 90 degrees, and have the result be (50, 100) in size.
The Ren'Py documentation is in the process of being rewritten. This changelog is now being maintained as part of the Ren'Py documentation.
Added support for composite style properties, that allow several style properties to be set using a single parameter. The new composite style properties are:
ui.add can now take transform properties as keyword arguments. If at least one transform property is present, ui.add will create a transform that wraps the displayable it's adding to the screen.
The new LiveTile()
displayable tiles its child, without consuming a
large amount of memory to do so.
config.quit_action
allows one to specify an action that is run when
the quit button (in the corner of the window) is pressed.
config.game_menu_action allows one to specify an action that is run when
entering the game menu.
The config.screenshot_crop
configuration variable controls the area
of the screen that it stored when the user presses the screenshot key.
The renpy.music.register_channel()
method now has two additional
parameters, file_prefix and file_suffix. These are prepended and appended
to filenames provided to the registered channel, respectively.
The new renpy.list_files()
method returns a list of files in the
game directory and archives. This can be used to write your own automatic
image loading method, among other things.
The interaction between Character and Text has been rewritten to ensure that text is only tokenized once. This required changing a few of the methods on ADVCharacter and NVLCharacter, so code that inherits from those classes should be checked.
The distribution code has been moved into launcher/distribute.py. This file can be run from the command line to build distributions in shell scripts and other automated processes.
When there are transparent areas on the screen, and
config.developer
is true, the transparent areas are filled with a
checkerboard pattern.
The new input
, side
, grid
, and fixed
styles were created,
and the corresponding displayables use them by default.
When a style is accessed at init-time, and doesn't exist, we divide it into two parts at the first underscore. If the second part corresponds to an existing style, we create a new style instead of causing an error.
The python compiler has been rewritten to use the python ast module. This should both improve performance, and improve error handling for python syntax.
Because of this change, Ren'Py now ships with and requires Python 2.6.
The following numbered bugs were fixed:
The following other bugs were fixed: