New in Ren'Py 6.9.1
-------------------

The music and video playback code has been completely rewritten. The
new implementation uses the ffmpeg library. It includes the following
features:

* Support for ogg, mp3, mp2, wav, and flac audio.

* Support for theora, mpeg4 part 2 (including DivX and Xvid), mpeg2,
  and mpeg1 video.

* Support for an arbitrary number of named channels, replacing the
  previous eight numbered channels.

* Audio files are now automatically converted to the output sampling
  rate (by default, 44100hz). This prevents the problems that would
  previously crop up when playing audio sampled at other rates.

* The play, queue, and stop statements now take a channel name as the
  second argument, which makes using user-defined channels easier. 

As part of this rewrite, we have eliminated support for mod formats,
as they are not supported by ffmpeg.

Please read the reference manual documentation for Audio and Movies to
learn the new interface.

The new code requires some changes in the saved data. As a result,
loading a file saved with a prior version of Ren'Py may lead to a lack
of music until the next track is played.



The new window statement allows one to control if an empty window is
shown when no character is speaking. Specifically, the

window show [transition]

statement shows the window, and the 

window hide [transition]

statement hides it. Both can take an optional
transition. config.empty_window is responsible for displaying the
window, while config.window_show_transition and
config.window_hide_transition are default transitions. The state of
the window can be determined by testing _window. The
renpy.shown_window function can be called to suppress displaying the
empty window, and is called automatically when characters speak.


Hotspots for the game menu buttons can be defined as part of
layout.imagemap_load_save, layout.imagemap_preferences, and
layout.imagemap_yesno_prompt. Doing so prevents layout.navigation from
being called for that screen. It also allows opaque imagemaps to be
used, rather than forcing them to be transparent to allow the
navigation to show through.


There is a new config.windows_icon variable, that lets one set the
window icon for Windows separately from Mac OS X and Linux.


Ren'Py now automatically scales itself down when it detects that the
game window is too large for the screen.


The define.move_transitions function can now pass keyword arguments to
the moves it creates. The most useful thing with this is to pass
subpixel=True, in order to create subpixel move transitions.


The Motion (including Move and Pan), Zoom, RotoZoom, and FactorZoom
displayables now use the style.motion style, which now has xanchor and
yanchor both set to 0. This gives these movements the same semantics
when used inside an image clause as they have outside one.


im.Grayscale and im.Sepia now take properties, so they can be
positioned.


The new renpy.get_placement function returns information about the
placement of displayables.


Improved the render management code, so there should no longer be any
leaks reported during shutdown.


Deal with the case where a bmfont has a negative offset for the first
character in a string.


Added more verbose diagnostics when illegal statements are run in the
init phase.


Added _rollback, which controls if rollback is enabled.


Added a target parameter to renpy.full_restart, which allows the main
menu screen to be selected after a restart.



Fixed a bug that caused layout.imagemap_main_menu to call a label even
though there was a button with the same name.

Fixed a bug that prevented Zoom from working in non-bilinear mode.

Fixed a bug that could cause buttons not not consume events when using
an imagemap main menu.

Fixed a bug that caused Transform to produce an incorrectly-sized
render.

Fixed a bug that could cause crashing when rolling back to a Zoom with
an after_child.

Fixed a bug that could cause segfaults when saving overly-complicated
images.


New in Ren'Py 6.9.0
-------------------

This release features a rewritten rendering system. The rendering
subsystem is what manages drawing to the screen. There have been
several major improvements:

* The render system has been simplified. Although still complex, it's 
  now easier to understand than the old system, while also being
  naturally a bit faster.

* That being said, the render system now focuses more on framerate
  consistency than raw speed. 

* The render system now supports subpixel drawing, drawing images at
  locations that are not integer pixel boundaries. This is enabled by
  setting the subpixel style property to True for a displayable. (It 
  makes the most sense to do this for Move and Pan, and less sense to
  do this for non-moving displayables.) 

* The render system supports specifying subpixel placement of
  displayables. This is done using the new absolute type. (A
  floating-point position is still interpreted as a fraction of the
  area in which the displayable is placed.)

* The render system supports a rotate-zoom-alpha mode, in which allows
  a displayable to be rotated, zoomed, and have its alpha
  changed. When this mode is used, the cost remains constant, even
  when multiple transformations are composed. Currently, this is only
  used by Transform and ui.transform.

* The render system supports rotating and scaling focusable objects.

Improved the transform routine used by RotoZoom and Transform. It's
now both more accurate and faster. On Intel computers, it is now
accelerated using MMX instructions.  


The image statement now implicitly places itself inside an init block
if it's not inside an init block to begin with. The code:

image bg world = "world.jpg"

is now equivalent to:

init 990:
    image bg world = "world.jpg"


When compiling python blocks containing strings with a unicode
character in them, Ren'Py will automatically prepend a u to any string
that's missing it. This should make life easier for users of non-ASCII
languages.


The new ui.autobar function makes it easy to make a bar that 
varies between two values over time.


The new renpy.Container class can be subclassed to create a user-defined 
displayable thatr contains other displayables, like Transforms.


The new im.FactorScale image manipulator allows images to be scaled by
a specified factor at preload time. This is generally faster than doing the
equivalent scaling at display time with FactorZoom.


The new renpy.sound.set_pan function allows sound and music to be
smoothly panned over time.


The new config.label_callback variable allows a function to be called
whenever control reaches a label. It can distinguish between jumps to
that label and control falling through.


There have been a couple of places where properly documented functions
have superseded semi-documented calls into the Ren'Py internals:

The renpy.game_menu and ui.gamemenus functions are now the preferred ways
of getting access to the game menu.

The ui.jumps function now takes a transition argument, allowing it to subsume
the undocumented _intra_jumps.


Ren'Py now looks for the file environment.txt in the directory
containing Ren'Py itself. If it finds it, it loads the file as a
python file, and uses it to set the default values of environment
variables. This allows things like the editor or the scale factor to
be set even on platforms that don't make it easy to change environment
variables globally.


The reporting of parse errors involving missing quotes has been
improved.


Changed the behavior of overlays during transitions. Now, both the old
and new screens will use the new overlay. Previously, the overlay was
cleared out during a transition, which didn't work well, as (for
example) a dissolve would cause the overlay to blink out and then
dissolve back in again.


MoveTransition and define.move_transitions have been changed to take 
a layers argument, giving the list of layers the transition applies
to. By default, this is only the master layer, which is a change in
their behavior.


Calling theme.roundrect() no longer implies layout.button_menu(). 


Ren'Py now autosaves when entering the quit prompt, and will not actually 
quit until this autosave is complete. 


The default framerate limit (config.framerate) has been raised to
100fps. This make tearing less noticable than on a 60hz screen.


Added renpy.partial as a version of renpy.curry that requires two
function calls, rather than three.


Fixed a divide by zero error that occured when Alpha was used for 0
seconds.


Libvorbis has been upgraded to version 1.2.0.


To reduce distribution size, OGG Speex support was dropped.


New in Ren'Py 6.8.1
-------------------

Added support for the iRex iLiad ebook reader platform.  This required
adding the following features, which may prove useful for other
platforms:

Added support for the RENPY_SCALE_WIDTH environment variable, which
allows the game to be scaled to a specific width, if it's larger.

Added support for the RENPY_LESS_MEMORY environment variable, which
reduces the amount of memory used by Ren'Py in exchanged for reduced
speed.

Added support for the RENPY_LESS_UPDATES environment variable, which
tries to reduce the number of screen updates to one per interaction.

Added support for the RENPY_LESS_MOUSE environment variable, which 
prevents the mouse from being shown.

The iLiad support was sponsored by Hixbooks.


It is now possible to rebuild the distribution of a game by unzipping 
it underneath the Ren'Py directory, selecting it as a project, and 
building the distributions. This makes it easy to upgrade the version
of Ren'Py used by a game, or to build a version of it that works on
your favorite platform.


The new Alpha function can be used to change the alpha level of a
displayable. (im.Alpha can only be used with other image
manipulators.)


User-defined statements are now documented in the reference manual,
making them officially supported.

A user-defined statement can now be used as the default
statement. This allows you to replace the say statement with an
alternate of your own devising.


Fixed a bug that occured when space characters were inserted
immediately after a newline.

Fixed a problem displaying a presplash image on the mac platform.


New in Ren'Py 6.8.0
-------------------

Ren'Py now includes its own font-handling library, derived from
pygame.font/SDL_ttf, which it uses in place of them when
possible. This gives two advantages:

* Outlined text is now possible. The new outlines style property
allows you to specify one or more outlines, including offset
ones. This allows for several fairly complicated text effects, similar
to what you'd see in modern subtitles.

* The bug preventing fonts from being archived has probably been
fixed. It should now be possible to include a font in an archive, and
have that work. The archiver has been modified to allow ttf files to
be archived again. Please report any bugs/crashes that occur.


There is now a new justify style property, that causes lines of text
to have additional whitespace inserted between words so that the left
and right margins are even, except on the last line of a paragraph.


Ren'Py now supports the MudgeFont and BMFont image-based font file
formats. The new renpy.register_mudgefont function is used to register
a MudgeFont, and the renpy.register_bmfon function is used to register
a BMFont.


Newly-created games will have a Help option on the main and game
menus. This is controlled by the config.help variable. By default 
the help system shows the README.html file in the game's base directory.


If the file icon.ico is present in the base directory, it will be used
as the icon of the windows exe when building the windows
distribution. Similarly, the file icon.icns will be used as the icon
of the Macintosh application. (Note that .icns is a different file format 
from .ico.)


On Mac OS X, Ren'Py will not change the application icon unless
config.window_icon is set. More specifically, it will default to the
launcher icon rather than a generic pygame icon.


The Macintosh application will now show the name of the game in the 
menu bar, rather than "Ren'Py Launcher".


The "Continue Game" option on the main menu has been renamed "Load
Game", for consistency with the game menu.


When config.developer is set and an undefined image is used in a show
or scene statement, a list of undefined images will appear centered at
the top of the screen. A black screen (configurable with
config.missing_background) will be shown instead of any missing
background. This makes it easier to write a script before all images
are present.


The newly-documented Style.set_parent method lets you change the
parent of a style. The new style.rebuild function allows styles to be
rebuilt even after the game has begun running, with some
caveats. (Changes are not persisted, for one thing.)


The new unscrollable style property allows one to choose how
unscrollbable scrollbars are displays. None keeps the current
behavior, which shows the bar normally. If set to "insensitive", the
bar becomes insensitive, while if set to "hide", the bar is not 
drawn at all.


The new renpy.easy_displayable method can be used by user-defined
displayables to convert strings into Solid or Image displayables.


Alt-F4 and Command-Q now trigger the quit event, as if you pressed the
quit button on the top of the window. The first press brings up the 
quit prompt, and a second press forcibly terminates the game. 

Alt-M and Command-M iconify the window.


The new RENPY_SCREENSHOT_PATTERN environment variable lets you
configure the name of screenshot files. Ren'Py can now write out
screenshots as JPGs, as well as PNGs.


Several of the libraries underlying Ren'Py have been updated. Pygame
has been updated to version 1.8.1, while Freetype is now at version
2.3.7.


The presplash code now looks for presplash.jpg in the game directory
if presplash.png is not found.


On Windows, config.window_icon will be scaled to 32x32 if it is wider
than 32 pixels. This allows the same icon to be used across platforms.


Custom mouse cursors should now be properly hidden when the mouse
leaves the window. Previously, this failed to work on the Mac OS X
platform.


The launcher has been moved into the launcher/ directory. This really
shouldn't matter much, but may affect packaging and translation.


New in Ren'Py 6.7.1
-------------------

Ren'Py now ships with jEdit as its default text editor. This means Java
1.5 or later is now required to edit scripts.


The Macintosh application is now universal, including both i386 and
ppc binaries. This means it should run faster on newer Intel systems.


Ren'Py will now use Launch Services to report errors that occur on the
Macintosh.


User-defined displayables can now use a canvas to draw lines, polygons, arcs,
and ellipses on the screen.


The new _window_subtitle variable allows a portion of the window
caption to be varied depending on the game circumstances. The new
config.menu_window_subtitle variable controls the value of _window_subtitle 
when in a menu.


Image preloading now takes place in a separate thread. This allows
image loading to proceed even while animations are playing on the
screen.


A new button in the launcher now provides easy access to the local
copy of the Ren'Py documentation.


The definitions of config.editor and config.editor_transient have been
changed. While it's simplified, older values may no longer
work. Please read the documentation for details of the new syntax.


Ren'Py now limits the framerate to 60 frames per second, which should
improve smoothness on fast enough machines.


Ren'Py now scans the game directory for all .rpa files, and adds them
to config.archives automatically. In addition, the archiver tool now
prompts for the name of archives, and uses filename patterns to decide
what to archive. This makes it easier to break the files up into
multiple archives, in a single game.


The new renpy.copy_images function copies images with one prefix to a
second prefix.


The launcher will no longer include directories beginning with a dot
(like .svn and .bzr) when copying the template directory to create a
new project.


This version includes a refresh of the character art included with
"The Question". The new art is by Deji, and the full-color version of 
the art is available from http://wiki.renai.us/.



New in Ren'Py 6.7.0
-------------------

The new layout.imagemap_navigation, layout.imagemap_preferences,
layout.imagemap_load_save, and layout.imagemap_yesno_prompt layouts
allow one to use imagemaps to define the game menu. Together with the
existing layout.imagemap_main_menu, the entire interface can now be themed
with imagemaps. (except for the rarely-used joystick preferences)


The new SplineMotion motion function, contributed by Aenakume, allows
motions to be specified using linear, quadratic, or cubic
splines. This allows complex non-linear motions to be specified. A
spline editor can be downloaded from: 
http://www.renpy.org/wiki/renpy/Spline_Editor


The new SizeZoom motion function allows displayables to be scaled to a 
specific size. Along with SizeZoom, the Zoom and FactorZoom functions get 
a new repeat argument that makes the zooms repeat.


If the new config.save_directory variable is set, Ren'Py will now try
to save games and persistent data underneath the user's home
directory. The precise directory saved to varies by platform:

* Windows: %APPDATA%/RenPy/<save_directory>
* Mac OS X: ~/Library/RenPy/<save_directory>
* Linux/Other: ~/.renpy/<save_directory>

Newly-created projects will have config.save_directory set to a value
based on the project name.

Since finding the save directory is now more difficult, the launcher
has gained an option that allows the user to easily delete a game's
persistent data.


A new variable, nvl_variant, allows one to change the styles used by
nvl-mode. or example, if nvl_variant is set to "foo", then
style.nvl_window["foo"] will be used instead of style.nvl_window.


The renpy.full_restart function now takes an argument that lets one
specify the label that will be restarted to. By calling
renpy.full_restart(label="start"), one can start a new game.


Software-drawn mouse cursors are now hidden when the mouse leaves the
window. Previously, the mouse cursor would be kept around in the same
place until the mouse re-entered the window.


The \ character is now the universal quote character. One can use \%
to prevent % from performing interpolation, and \{ to prevent { from 
starting a text tag.


Using stdin for the remote control didn't work on Windows, and could
lead to errors in some cases. Instead, the remote control mode now 
uses a file, which gets deleted after processing the command.


Improved the numerical stability of interpolation. This fixes a
problem where moves could wiggle from side to side for no good 
reason.


The archiver will now cowardly refuse to archive .ttf files. This is 
because reading those files out of an archive will crash on windows.


The new config.clear_layers variable allows layers to be cleared out
when entering the game and main menus.


Fixed style inheritance, which in some cases wouldn't pick up the
style inherited from.

Fixed a bug that made image prediction fail when a hide statement was
encountered.

Fixed a bug that prevented im.AlphaMask and ImageDissolve from working
with some images. Also improved the quality of im.AlphaMask, which was
incorrectly blending fractional alphas with black.

Fixed a bug where style inheritance did not work properly.

Fixed a bug where the launcher could choke when launching non-English
gamedirs.

Fixed a bug that prevented the style inspector from working on animated
screens.

New in Ren'Py 6.6.3
-------------------

Ren'Py will now error out quicker if you give it None when it's expecting
a displayable. This makes it more likely the correct line will be 
reported when a problem occurs.


Added a new remote-control mode, that allows Ren'Py to be commanded to
perform a number of things, by sending the appropriate command to 
stdin. This is useful for editor integration, as it allows for 
warping to an appropriate line.


Music and sound-effects are now stopped when returning to the main 
menu, save for channel 7. The music on channel 7 is only stopped if
it is not the same as the config.main_menu_music, otherwise, it is 
allowed to continue playing.


Allow a thumbnail to be used with classic load-save.


The {w=<pause>} text tag now compensates for slow text, and will only
begin the pause once all text has been displayed.


Lint will no longer produce an error when encountering a user-defined
text tag of the form: {/=style}. 


Change renpy.Displayable so that subclasses of it participate in 
rollback.

Fixed two bugs that could cause incorrect saving in the presence of 
empty lists and dictionaries.

Fixed a bug that could cause crashing due to non-integer blitting of
renders.

Fixed a bug that could cause crashing under certain combinations of
layouts and transitions.


New in Ren'Py 6.6.2
-------------------

The new layout.imagemap_main_menu function makes it easy to use
imagemaps to define the main menu.


The new {s} text tag causes text to be struck-through. The new 
{=style_name} text tag cause text to be rendered in the given style
(for example, {=foo}text{/=foo} causes text to be rendered in the foo 
style.


The config.main_menu and config.game_menu variables can now optionally
take 4- and 5-component tuples, respectively. In both cases, the new 
last component is a python expression that must be true for the button
to be shown.


The config.after_load_transition variable can be used to specify a
transition that occurs after a game has been loaded. 


Calling renpy.restart_interaction() will no longer cause ongoing
transitions to be terminated.


The new config.hyperlink_styler variable allows the style of
hyperlinks to be changed based on the argument to the hyperlink.


Now, the nvl_window style also gets indexed by "rollback" when in
rollback is occuring.


The JPEG library has been recompiled with optimization enabled, which
should allow for somewhat faster image loading.


Fixed a series of issues that made _window_during_transitions interact
poorly with click-to-continue.

Fixed windows font-scanning code. Updated to the pygame 1.8 version of
the unix font-scanning code, which actually stands a chance of working
on a modern Linux system.

Fixed a crash when right-clicking at a yes/no screen, and a crash when
using NVL-mode and jump.

The use of tab to toggle skipping is now disabled while inside the
game and main menus.

Pressing control will no longer cause transitions to end when
config.allow_skipping is False.

New in Ren'Py 6.6.1
-------------------

The various styles used by the say statement are now indexed with
"rollback" when rollback has occured. This makes it possible to indicate
to the user that they're in rollback mode.


Setting config.nvl_paged_rollback will change the rollback mechanism
to display entire pages of rollback at a time. For this to work,
page-ends need to be predictable, which generally means nvl clear
statements should immediately follow nvl-mode dialogue. (As opposed to
occuring only after a page has finished.) This doesn't work well when
mixing ADV and NVL modes, as the idea of a page isn't well-defined in
that case.


Added a new _preferences.afm_enable preference. Setting this to False
will disable auto-forward mode, while setting it to true will
re-enable it. This allows the creating of a button that toggles
auto-forward mode.


The new renpy.pop_return() function pops a level off of the return
stack. This allows for a multi-level return.


MoveTransition now takes an old argument, which causes it to move the
old image, rather than the new one. This lets one (if you use
define.move_transitions to define a family of transitions with
old=True) use ComposeTransition(dissolve, oldmove, move) to dissolve
between two sliding images.


config.auto_save_extra_info now lets you specify the extra_info that
will be included as part of auto-saves. It defaults to a function that
returns save_name, so the save_name will now be included as part of
auto-saves.


renpy.in_rollback lets you query if Ren'Py is currently in rollback 
mode.


Somewhat improved the performance when large numbers of displayables
are on the screen at once.


Fixed a bug that caused memory corruption when faced with an audio
frame that was not a multiple of 8 samples (16 bytes) long. 

Fixed a bug that prevented MultiPersistent from working.

Fixed a bug that caused bilinear scaling to sometimes fail.

Fixed a bug that caused weird (often unrelated-seeming) problems with
ImageDissolves.

Fixed a bug that cause large memory leaks.

Fixed a bug with the {nw} text tag.

Fixed a bug in the style inspector.

New in Ren'Py 6.6.0
-------------------

This release features a total rewrite of the out-of-game menus, which
divide these menus into themes which control the look of the menus,
and layouts which control the feel (layout and functionality) of the
menu components.

Writing new layouts and themes has been made much easier by
documentation listing what is required for each. There are also a
number of new layouts, one new theme (outline).

Games are now required to select a theme before they can operate
properly. The implicit theme from the previous version of Ren'Py has now 
been turned into the ancient theme. 

Finally, to ensure older games can operate in this new version of Ren'Py, 
a compatibility mode has been added. This mode is engaged automatically if 
config.script_version is set to (6, 5, 0) or less.


This release features a new developer menu. Hit Shift+D to access it.


Ren'Py now supports modules which can be loaded with the
renpy.load_module function. Modules are stored in .rpym files, which
get compiled down to .rpymc files.


The order of style inheritance has been changed when nested styles are
involved. Now, assuming that style.child inherits from style.parent,
then style.child['index'] inherits from, in order:

* style.child
* style.parent['index']
* style.parent

This makes it possible to define imagebuttons and imagelabels in the
style.button and style.label styles, rather than in all sorts of
different styles.


Windows and Buttons now take a new size_group style property. This
property, when not None, should be a string giving the name of the
size group the window or button is in. All windows and buttons
belonging to the same size_group are treated as if they had a minimum
width equal to the width of the widest button in the group.


The Begin Skipping command has been moved from the game menu
navigation to the preferences screen.


A new suppress_overlay variable has been added. This variable
suppresses the display of overlay functions when set to true. It's
automatically set to true when entering the menus.

The default underlay now is compatible with menus. This makes it
possible to do things like take screenshots while in a menu. 


Applied Hentai Senshi's patch that adds a config.editor_transient
variables. The default editor will no longer clobber changed files if
they are opened twice, while the transient editor will.


Frame now supports a bilinear argument, which controls if bilinear
scaling is used.

Ren'Py now uses an improved multi-step bilinear scaling algorithm that
is more correct when scaling by a factor of less that 1/2.

Save thumbnails now use bilinear scaling.


Made more syntax errors display the proper line number.

Fixed a regression that caused the performance of dissolve to be
substantially degraded.

Fixed some bugs in imouto-mode.

The Windows build now uses directsound for sound playback, where
available. This should noticably reduce sound latency on systems that
support it.


New in Ren'Py 6.5.0
-------------------

We are now using Python 2.5. Python 2.5 syntax should be allowed any
place that python syntax is allowed.


Rewrote the Bar class, which implements ui.bar. This class now
optionally takes an adjustment object, which is what stores
information about the range, value, page size, and step size of 
the bar. Scrollbars can now indicate what fraction of the viewport is 
being shown.

Bars now take a new style property, bar_resizing. If this is true, we 
resize sub-bars, rather than rendering them at the full bar size and
then cropping. This changes the look of bars a bit.

Viewports now use adjustments to control their x and y scrolling
information. They properly fill in a range and step size, allowing
scrollbars to indicate the fraction of the viewport that is being
displayed to the user. 

Viewports now also support several new ways of scrolling around. If
a true mousewheel argument is given to ui.viewport, the user will be
able to scroll the viewport using the mousewheel. If the draggable
argument is true, then the user will be able to drag the viewport
around using the mouse. 


We have implemented a new container, ui.side. This container divides a
space into the center, four sides, and four corners, and allows one
displayable to be placed in each.


Windows (and related things, like frames and buttons) now take a new
foreground style property. This is like background, but it goes on top
of the rendered child of the image. It could be used to add things
like shines to buttons. 


The new im.matrix.hue function returns a matrix that can rotate the
hue of an image.


We have implemented a new family of transitions, the ease
transitions. (Such as ease, easeinright, easeoutbottom, etc.) These
are counterparts to the equivalent move transitions, that use a
cosine-based function to slow the start and/or end of the move as
appropriate. The new define.move_transitions function simplifies the
creation of your own family of move transitions.


Modified the default hyperlink handler such that a link of the form:
{a=http://www.renpy.org}link{/a} will bring people to a web page in
the user's default web browser. Modified config.hyperlink_callback so
that if it returns a value, that value will be returned from the
current interaction. (For example, one could have it return True to
end a say statement.)


Dissolve and ImageDissolve now take an alpha argument. If this
argument is True, the alpha channel is preserved across dissolves, at
the cost of some speed.


There is a new renpy.get_all_labels function, that returns the set of
all labels defined in the script.
User-defined statements can now be provided a next function, which is
called to get the label of the statement to be executed after the
current one.


Modified SnowBlossom to take a new parameter, horizontal, that causes
it to move particles in a horizontal direction.


Renamed two style properties: box_spacing is now spacing, and
box_first_spacing is now first_spacing. These properties can now be
used by grids and sides. The old names are left in as aliases.


The archiver will now ignore presplash.png.


Lexer tokens beginning with __ and not containing __ are now munged in
a filename-dependent manner. This means that one can use __word in a
file, and be sure it will not conflict with __word in a different file.


Various performance enhancements, guided by profiling.


Fixed a bug that made syntax errors more confusing than necessary.

Fixed a bug that caused corruption in zip files created by the launcher.

Fixed a bug that prevented image prediction from working in many cases.

Fixed a bug that prevented {w} from working when a ctc indicator was set, 
but a ctc_pause indicator wasn't.

Fixed a bug that manifested when a RotoZoom was larger than the screen.

Fixed a bug that prevented At from being applied to Motions in init blocks.



New in Ren'Py 6.4.0
-------------------

Rewrote the way in which dialogue is handled. This has a number of
repercussions, although it should be mostly backwards-compatible for
existing games.

The first change is that Character is now a function, rather than a
class. It can create instances of the new ADVCharacter and
NVLCharacter classes, which are the classes responsible for managing
dialogue. 

The Character function takes a new kind argument. This argument takes
another character object that is used as a template for the object
being created. It defaults to the adv character object when a
Character or ADVCharacter is being created, and the nvl character
object when an NVLCharacter is being created. The new preferred way to
create an NVLCharacter is to write:

init:
    $ envl = Character("Eileen", kind=nvl)

By defining a new adv or nvl character, it's possible to change the
behavior of all characters of the given kind defined after that one.

The default narrator is now a character. There is also a new character
object, unknown, which is copied and used when an unknown character
(that is, one with a string for a name) speaks. 

Characters now take a new ctc_pause argument. If supplied, it gives a
click-to-continue indicator that is used when the {p} or {w} text tags
cause the display of dialogue to be paused.

Added config.nvl_page_ctc and config.nvl_page_ctc_position. If set,
these override the ctc and ctc_position parameters of a character
during dialogue when the next statement is "nvl clear". 


Added a new variable, mouse_visible, that controls if the mouse 
should be visible at any given moment.


renpy.with_statement and ui.interact now take a clear argument, which 
controls if the transient layer is cleared at the end of a transition
or interaction.


The new At function provides a nicer syntax for applying position
objects (the result of Position, Move, etc.) to displayables.


Added ui.callsinnewcontext as an alias for renpy.curried_call_in_new_context.


Added the new renpy.seen_image and renpy.seen_audio functions, which
keep track of the images that have been seen and the audio that has
been played, respectively.


Added renpy.current_interact_type, which is the counterpart of
renpy.last_interact_type.


The screenshot displayables returned from renpy.list_saved_games and
renpy.scan_saved_game are now image manipulators, which means that
other image manipulators can be applied to them. For example, one can
apply im.Sepia to a screenshot to sepia-tone it. The new 
_file_picker_process_screenshot function can be overridden by the 
user to change the look of the game in the current menus.


The config.label_overrides variable is a map that allows one label 
to be overridden by another.


Modified the behavior of return so that it evaluates the return
expression with the values of dynamic variables found inside the
function that has been called.


Fixed viewports so that they properly block access to buttons that are
outside the viewport.


Patched SDL so that it can properly set non-ascii window titles on
Microsoft windows.


Upgraded the version of Python used in the Windows build of Ren'Py to
2.3.5. (Shockingly, we had been at 2.3.3 all this time.)


This release is dedicated to the memory of Sindu the Cat (1992-2007).



New in Ren'Py 6.3.3
-------------------

Raised the minimum supported Mac version to 1.4. No code was changed
to break compatibility with 1.3, but such compatibility hasn't been
tested in ages... Caveat Emptor.


The new im.AlphaMask image operator lets you use an image to
alpha-mask another. The new config.missing_image_callback lets you
specify a function that's called when an image is missing. Together,
they provide the necessary infrastructure for JCC--- JPEG Compression of
Character art.


The code for supporting hyperlinks (the {a} text tag) has been
rewritten. It is now possible for hyperlinks to span more than one
line. It is also possible to have code run when a hyperlink has been
focused, using the config.hyperlink_focus callback. 

This necessitated some changes to how hyperlinks work. They are no
longer buttons, so style.hyperlink is no longer used... now, only
style.hyperlink_text is used to change the look of a hyperlink.


The new ui.timer function lets you call a function after a certain
amount of time has passed. The function may be called once, or it may
repeat. 


The ui.remove function removes a displayable from a layer.


The new config.say_menu_text_filter variable can be used to preprocess 
strings found in say and menu statements.


The subtitle layout algorithm now properly deals with newlines.

The {nw} text tag now suppresses text after it, and click-to-continue
indicators.

Fixed bars so that they can be decreased using the keyboard.



New in Ren'Py 6.3.2
-------------------

Recompiled the Windows version using GCC 4.1. This should lead to some
performance improvements.

When config.developer is set to True, hitting shift+D will display the 
value of every varible that has been changed since the end of the init
phase.

East Asian (Chinese and Japanese) line breaking support is now
included in Ren'Py proper. It can be enabled by setting the language style 
property of a text field to "eastasian". 

Lint has been improved to now check that files used by styles exist.

Documented how displayables work, and how users can define their own
displayables. This involved making public the types renpy.Displayable,
renpy.Render, and renpy.IgnoreEvent; and the functions renpy.render, 
renpy.redraw, and renpy.timeout. 

Added in support for the new renpygame extension, which allows many
pygame games to be run under Ren'Py.

Added a new function, renpy.free_memory, that causes Ren'Py to
temporarily reduce it's memory usage. This is useful to prepare 
for a game.

The .rpa format has been modified slightly to make it work better with
DLsite's protect mechanism.

Modified Ren'Py so that when using the mouse to focus overlapping
buttons, the topmost button is the one that's focused. Previously the
order was undefined (and happened to be the lowest one). The keyboard
focus behavior of overlapping buttons is still undefined.

The distribution code in the launcher has been simplified.

Bug fixes in lint and styles.

Fixed a bug that prevented the Linux version from working when
installed on a path that includes a space in the name.


New in Ren'Py 6.3.1
-------------------

The image prediction mechanism has been improved. Now, it tracks the
names of images that will be shown to the user.


There are two new displayables. ConditionSwitch chooses a displayable
based on a series of conditions, while ShowingSwitch makes the choice
based on what other displayables are being shown. ShowingSwitch takes 
advantage of the new image prediction information.
 

Changed the behavior of renpy.showing. Now, renpy.showing can
determine which images are showing, as opposed to which image tags are
showing. This also takes advantage of the new image prediction
information.


Added a new renpy.get_at_list function, which retrieves the at_list
that was used to show a given image.


Add the renpy.layer_at_list function. This sets an at_list that
applies to a layer as a whole, allowing you to perform certain absurd
effects, like zooming into an entire layer as a whole.


The roundrect theme now support putting a vertical gradient on buttons
and sliders. See theme.roundrect for more details.


Changed the focus code so that when a mouse event ends an interaction,
the displayable underneath the mouse at the start of the next
interaction will become focused.


Disabled joystick support in the launcher, so that it doesn't conflict
with joystick support in the game proper.


Now, command-line arguments preceded by --arg will be stored in
config.args.


Pixellate and save thumbnails now work when in imouto-mode.


Fixed a bug in the subsurface code that prevented the various CropMove
transitions from working.

Fixed a bug that prevented ui.at from working.

Fixed a bug that prevented saving after using a Minigame.




New in Ren'Py 6.3.0
-------------------

There is a new style inspector, which can be activated with 'I' when
config.developer is true. The style inspector shows the contents of 
the transient and overlay layers, and for each displayable shows the 
type of displayable, the style used, and the size it's rendered to.


We now support indexed styles, which can be accessed by indexing a
style with a value. These are lightweight styles, that do not take up
any space unless they have a value set. The main and game menus have
been modified to take advantage of these indexed styles, allowing just
about everything on those game menus to be customized individually.


The activate_ property prefix has made a comeback. This prefix is
applied to buttons that have been selected by the user. It is applied
when the button is first selected (while the clicked function is
running). If the clicked function returns a non-None value, or an 
exception, then the button remains activated forever.


Styles may now be constructed using the Style function, and accessed
directly off of the style object, rather than always being referred to
by name.


The Fixed displayable has been merged with the MultiBox displayable
(which is what implements HBox and VBox). The box_layout property 
now has a new value, 'fixed', which can be used to turn an HBox or
VBox into a fixed layout.


The new xoffset and yoffset placement properties allow one to specify 
a pixel offset to the position computed using xpos/xanchor and
ypos/yanchor. This makes it easy to specify, say, that a button's
label should be a pixel or two above center.


The default roundrect theme now takes a new argument, less_rounded. If
True, this will use the 6-pixel rounded rectangles, even on an 800x600
game. This is the default for new projects.


Added im.MatrixColor, an image operator that uses a matrix to alter
the colors in an image. This can be used by objects of the im.matrix
type, which can be constructed by the im.matrix.identity,
im.matrix.saturation, im.matrix.desaturate, im.matrix.tint,
im.matrix.invert, im.matrix.brightness, im.matrix.opacity, and 
im.matrix.contrast functions.

We also have created two convenience wrappers for im.MatrixColor:
im.Grayscale and im.Sepia.


The mouse is now hidden after 30 seconds of inactivity, as a boon to
Joystick and keyboard users. (The time is controlled by
config.mouse_hide_time.) 


The renpy.imagemap function is no longer limited to images. It can now
take arbitrary displayables, like animations.


Buttons now take a new time_policy style property, which can be used
to warp time for the children of the button. We took a mulligan on the
initial_time_base style property, which has been removed. 


Added a function, renpy.file, that will open a read-only file-like
object from a file that exists in the game directory or in an
archive.


Added a function, renpy.seen_label, that returns True if a label has
been executed at least once, in any execution of the game.


Setting _game_menu_screen = None prevents the game menu from being
shown. (Setting it to a value like "_save_screen" or "_load_screen"
shows the game menu again.) This is the default during the
splashscreen. 


NVLCharacter has a new parameter, clear, that if true causes the nvl-mode
screen to be cleared after that character speaks. 


Rewrote the input handling code. Now, we can deal with keysyms prefixed 
with alt_, shift_, and noshift_.


Show text and centered now display their text using the "subtitle"
layout algorithm, which tries to minimize the difference in line
length. 


Made it so that {nw} interacts properly with NVL-mode.


Using backslash '\' in filenames now triggers an error message, even
on Windows. Use forward-slash ('/') instead. 


Made it so that MPEG-1 movies can be read out of archive files.

Fixed Ren'Py such that movies properly loop when required. Changes
renpy.movie_cutscene so that it allows delays of None, which will delay
until the movie is done playing, and -1, which will cause the cutscene
to wait until the user clicks.


Fixed a bug that prevented ui.at from working properly.


Added the mouse style property, which specifies the mouse cursor that
is used when a displayable is focused.

New in Ren'Py 6.2.0
-------------------

Added a new "extend" pseudo-character. When "extend" says something, the 
last character to speak says the last thing to be said, "{fast}", and 
the new thing being said. This makes it easy to have a character
say something, wait for a click, change their expression, and then 
say something else in the same block of text. For example:

e "Sometimes I'm feeling a bit down..."
show eileen happy
extend " but I get over it!"

Added a {nw} text tag. Including this text tag in a string causes the
text to immediately dismiss once the string has been fully shown. This
is useful in conjunction with extend, to have a character change
expression when slow text gets up to a certain point.


The new nvl_erase function erases the last line of text said in
NVL-mode, allowing you to replace it with something else.


Added anim.TransitionAnimation, a way of specifying animations that
use a transition between each frame. 


Added dynamically-scoped variables. When a variable is declared to be
dynamically scoped, changes to its value are reverted when returning 
from the current call. Variables are declared dynamic using the 
renpy.dynamic function.

Added the ability to call a label with arguments. These arguments are
placed into the parameters specified by the label, which are
dynamically-scoped variables. 

The return statement can now take an expression, which is placed into
the _return variable.


Added auto-saving. This causes Ren'Py to save the game at semi-regular
intervals (currently, around every 200 interactions). The saves take
place in a background thread, so they shouldn't interfere too much
with normal game operation. The saves also only occur when the game
has 250ms with nothing scheduled. 

Adding autosave required a rewrite and minor redesign of the load/save
screens. There is now a new page, "Auto", that contains the autosave
files. To make room for this page, we reduced the number of quick page
access buttons to 8. (You can still access an unlimited number of
pages by hitting "Next".) The text in these screens has been reduced
in size by 2 pixels, this is to make room for the longer filenames
(like a10).


The scene, show, and hide functions now use config.scene, config.show,
and config.hide, which default to renpy.scene, renpy.show, and
renpy.hide, respectively. By changing the config variables, the user
can intercept the guts of these statements.

The character callback now gets the cb_-prefixed keyword arguments 
that are passed to Character, if any.


There are now three new styles for bars. Along with bar, there is now
scrollbar, vbar, and vscrollbar. The roundrect theme styles each 
kind of bar appropriately.

Added a new Viewport displayable. This lets you display something
that is bigger then the area alotted to it, and to use scrollbars to
scroll around inside. Viewports can be created with Viewport or 
ui.viewport.


Modified the {w} text tag, so it can also be written as {w=number},
where number is a number giving the number of seconds to pause for.


The script is now loaded before the persistent object is created. This
lets "python early" blocks update config.savedir, which means that a
script can now find the save directory by itself, when running off 
of read-only media. (Try not to be too windows-centric, 'kay?)


In one of those "anticipating future needs" sort of changes, changed
Button to set the displayable timebase of its children to 0 each time
the button becomes hovered or idle. This makes it possible to animate
a button becoming hovered or idle, by using an animation as the
background. (Or by using animations in a ui.imagebutton.) The new
initial_time_offset property controls the displayable timebase when
the button is first displayed, allowing the animation to be skipped
when not invoked by the user. (Note that to use the displayable
timebase, you'll often have to set anim_timebase=False.)


Rollback is now disabled when in code called in a new context.


Adjusted spacing in the text box a little bit, so that it's now
possible to have four lines of text without stretching the text box.


Lowered the sound buffer size from 4096 to 2048 samples. This should
hopefully reduce sound latency. Made code in the Ren'Py module
non-blocking, to allow music to run even while the main code is 


Switched back to using cPickle for pickling. CPickle will cause a
C-level crash when using a highly-nested data structure. (The pickle
module we're using will cause a python traceback in the same case.)
Setting the new config.use_cpickle module will disable the use of
cpickle for save and load.


Recompiled SciTE to include support for Lua scripting.



New in Ren'Py 6.1.1
-------------------

Introduced the "Black Screen of Death". Now, if an exception occurs 
during a shift+R reload, instead of exiting, Ren'Py displays the 
black screen of death. The black screen of death allows the user 
to choose between trying again and exiting Ren'Py.


Added a mechanism that allows extensions and patches to Ren'Py to be
distributed in .rpe files. (This isn't intended for game-developer 
use.)


Fixed a bug that caused the play music statement to ignore the channel
clause.


Fixed a bug that prevented lint from working on games containing voice
statements.


Added in files that were accidentally omitted. These files made the 
Ren'Py module unbuildable.

Modified renpy-deps to make them buildable on the x86_64 architecture. 


Eliminated remaining uses of the identifier "with", which will become
a keyword in Python 2.6.


Implemented a new trace mode that will help to diagnose problems with
Ren'Py itself. Supplying the --trace option to Ren'Py will write
information about function calls to trace.txt. Supplying --trace twice 
will also dump information about line execution and function
returns. Note that trace mode comes with a significant speed penalty, 
when active. 


Added code that helps Ren'Py run from read-only media.


Removed the "Quick Backup" option from the launcher, as it was
tempting, but not a replacement for a real backup solution.



New in Ren'Py 6.1.0
-------------------

!!!
Added support for Windows Vista. Previous versions of Ren'Py will
not run on Vista without a fix. Please do not release with 
earlier versions of Ren'Py.


Implemented hard pauses, pauses that cannot be interrupted by the
user. They can be invoked by passing hard=True to renpy.pause, but
it's probably a bad idea to use them. You should strongly consider
using "with Pause()" instead, as that lets you develop timed sequences
that can be aborted with a single click.


Added a handful of new config variables controlling transitions:

 * config.end_splash_transition is used to display the main menu after
the splash screen.
 * config.main_game_transition is used to display the game menu when in 
the main menu. 
 * config.game_main_transition is used to display the main menu after 
leaving the game menu.
 * config.end_game_transition is used to display the main menu after the 
game ends. 
 * config.intra_transition is used between screens of the game menu. Now, 
it is also used when a yes/no choice is displayed.
 * config.adv_nvl_transition is used when an adv-mode screen is immediately
followed by an nvl-mode screen.
 * config.nvl_adv_transition is used when an nvl-mode screen is immediately 
followed by an adv-mode screen.

We still support config.enter_transition and config.exit_transition,
which are used when entering or exiting the game menu from the game
proper.


There are now new slow_cps, slow_cps_multiplier, and slow_abortable
properties, that control the slow text effect. The slow parameter to
ui.text and Character has been modified slightly, so that if the user
specifies slow_cps without specifying slow, the slow_cps will still take
effect.


The roundrect theme has been updated to color insensitive file picker
entries with the disabled color.


Ren'Py can now re-show the last say statement. This is done by calling
renpy.reshow_say. renpy.get_reshow_say() allows the screen to be
retrieved, and reshown at some time in the future.


Documented a functional equivalent of the with statement,
renpy.with_statement(). This replaces the equivalent (undocumented)
function renpy.with(), which is now deprecated, as it is not compatible 
with the upcoming python 2.6 release.


We now track the type of the last interaction. This is determined by
supplying the type parameter to ui.interact or Character, and can be
retrieved using renpy.last_interact_type.

The new renpy.get_transition function allows one to determine if a
transition has been set for the next interaction. The renpy.with_statement
function (equivalent to the with statement) 

The callback system that is used for character dialogue has been
improved. The slow_done callback is now always called. Characters can
take a list of callbacks as well as a single callback. The new 
config.all_character_callbacks variable can be used to specify a 
list of character callbacks that are called by all characters.


NVL-mode now properly removes nestled click-to-continue indicators.


Ren'Py now releases control over the mixer when all mixers are set to
zero. This makes it easier to play alternative music in the background
of a game.


Ren'Py now uses a higher-resolution timer, preventing framerate from
being limited by timer resolution.


Dissolve has been rewritten to improve color correctness, at the cost
of a speed decrease on non-MMX platforms.


Rewrote the style system to use lists indexed by integers rather than
dictionaries indexed by strings. This change shouldn't be user
visible, except perhaps as improved speed and decreased memory usage.


Implemented Imouto-mode, an experimental new feature. Setting the
RENPY_SCALE_FACTOR environment variable to a number, will cause Ren'Py
to scale the game by that factor. For example, setting
RENPY_SCALE_FACTOR=.5 will cause the game to scale to half the normal
size. This is done in a memory efficent way... scaling to 1/2 the
size will cause the game to use 1/4 of the memory storing images.


Fixed a bug that caused recompilation on startup, on Windows
systems. This should improve startup time.



New in Ren'Py 6.0.0
-------------------

Changed main menu image to the 6.0 image.

Modified the "doesn't expect a block" error message, to better convey
that the problem is with the next line.

Everyone who contributed to the 5.6 series once again has my thanks!


New in Ren'Py 5.6.7
-------------------

A quickstart manual has been included in the documentation, with a
sample game, "The Question", included in the "the_question"
directory. Thanks to Alessio, DaFool, derik, Kathryn, and mikey for
contributing it.

Several new statements have been added to Ren'Py. These include the
play, queue, and stop statements that control the playback of music
and sound, the voice statement that plays voice, and the nvl
statements that are used in nvl-mode. While the old (python function
based) ways of invoking this functionality will still work, using the
statement allows lint to check your code for errors, like missing
files. 

These statements use the new user-defined statement support, which is
"documented" in common/00statements.rpy. 

Ren'Py now ships with many color variants of the roundrect
theme. The launcher can now change the color theme of a game, as
well. Thanks to absinthe for making these color schemes.

There have been improvements to error handling. The big one is that
parse errors are now reported all at once, rather than one at a
time. Several error messages have been clarified, to better let the
user know what is going on.

The drop_shadow style property can now take a list of drop-shadow
offsets. This can be used to outline text, without requiring the use
of a SFont.

When building a distribution, the launcher now prompts for a list of
file extensions to ignore. Files with these extensions will not be
included in the distribution.

Documented loading/saving, voice, and nvl-mode.

Names of files in the common directory have been prefixed with
00. This reduces the risk of naming conflicts, and ensures they are
loaded before other files. The latter allows user-defined statements
to be used.

The renpy.code file no longer contains the code for Ren'Py
proper. This means on windows, one must always distribute the renpy/
directory, or else a zipped up version as renpy.zip. This change
reduces startup time on Windows.

The DejaVuSans font has been updated to a newer version.

A new config.character_callback variable has been created, which
allows one to specify a character callback for characters that do not
define a more specific one. Character callbacks are now called for 
a "show_done" phase, after the show_function has been called.

The new config.default_fullscreen and config.default_text_cps
variables control the default values of the fullscreen and text speed
preferences, respectively.

+++
Midi support has been dropped, and will now trigger an error.

!!!
A bug has been fixed that prevented sound playback on older Linux
systems. 

!!! +++ 
A long-standing bug has been fixed that caused fadeout and
fadein times to be incorrect. This may cause the timings of fadeins
and fadeouts to change (to be what was specified in the appropriate
calls).

Fixed a bug that prevented the if_changed parameter to
renpy.music.play from working.

Text displayables no longer use an inner function in any case, which
should better allow them to be saved. Previously, there were some
problems when slow=True was set.


New in Ren'Py 5.6.6
-------------------

This release includes a number of new transitions. The movein
transitions (moveinleft, moveinright, moveintop, moveinbottom) move
newly-added images onto the screen from the appropriate side. The
moveout transtions (moveoutleft, moveoutright, moveouttop,
moveoutbottom) move newly-hidden images off of the screen.
The zoomin and zoomout transitions zoom in newly-added image, and 
zoom out removed images, respectively.

All of these are made possible by new arguments to MoveTransition,
which allow it to also process images that are entering and leaving
the scene.

Transitions can be composed using ComposeTransition. For example, one
could dissolve together a moveoutleft and a moveinright. Note that not 
all transitions can be composed.

The new RotoZoom feature allows images to be rotated and zoomed around
their central point. The new Revolve feature allows images to be
revolved around a different point.

The positions of elements of the file picker can be customized with
config.file_picker_positions.  The positions of preferences can be
customoize with config.preference_positions and
config.joystick_preference_positions.

We now support a "show image" syntax that, while identical to "show
expression", is easier to type. (Ditto for scene and hide.)

The file picker now shows the selected page with the selected style,
rather than the insensitive style.

The config.button_properties, config.button_text_properties and
config.label_properties variables can be used to specify properties
for specific game and main menu buttons, based on the text of the
button or label.

The ui.at function can take a position (or other effect), and apply it
to a widget added with the other ui functions.

The hovered callback to the various kinds of buttons now can return a
value. If a non-None value is returned, the interaction is terminated,
and the value is returned from ui.interact. Try not to abuse this, okay?

Motion now takes a add_sizes arguments, which causes the interpolation
function to be supplied with the sizes of the area in which the object
will be placed, and the size of the child.

All graphics are now 32 bits per pixel. Previously, we used a mix of
32 and 24bpp, but ran at 32 in most circumstances.

It is now possible to supply a function that determines if the say
statement is allowed to be dismissed, by setting
config.say_allow_dismiss. ui.saybehavior has been updated with similar
functionality. This was added to support children's games, where
dismissing dialogue before it's fully spoken harms the value of a game
as a pedagogical tool... this functionality should not be used in visual 
novels aimed at adults.

Two fixes for the Mac. One is a fix for platform.macsos_version when
used on older macs, while the other fixes a problem that manifested
when clicking the dock icon.

The new magic circle art is by Jake. Thanks!


New in Ren'Py 5.6.5
-------------------

The reference manual once again ships with Ren'Py.

Lint now checks for improperly matched text tags, and for
syntactically incorrect formating codes. Note that it cannot check for
the use of undefined variables in an otherwise correct formatting
code.

The new config.image_buttons and config.image_labels variables can now
be used to replace the buttons and labels (respectively) found on the
game and main menus with image-based replacements.

The new focus_mask property allows image buttons to take a mask image
that defines where the mouse must be for it to be focused. The
focus_rect property lets a subrectangle be used to specify focus, when
two imagebuttons overlap.

The show statement now takes a 'behind' clause, which gives a list of
image tags the current image should be shown behind.

Ren'Py (not python) strings can now be quoted with ` as well as " and '.

We now store a digest of .rpy files in the corresponding .rpyc
file. This will allow us to detect that the .rpy file has changed,
even if there are problems with the system clock.

The default who_suffix for characters has been changed from ': ' to
'', that is, to the empty string. (We believe this improves the look of
Ren'Py games.)

Fixed minor bugs in the launcher.


New in Ren'Py 5.6.4
-------------------

Implemented the ui.keymap function, which lets one easily map keys to
functions.

There are now two new functions in the NVL-mode. The nvl_show function
shows the NVL window with a transition, and the nvl_hide function
hides it with a transition.

Modified the launcher so the user can chose which files are archived
by the "Archive Files" tool. (Which has been renamed from "Archive Images".)

Fixed a bug that prevented new projects from being created under
Linux.


New in Ren'Py 5.6.3
-------------------

The demo has been rewritten from scratch, to better reflect the modern
way of coding Ren'Py.

The extras/ directory has been eliminated. Voice.rpy is now included
in common/ as part of the standard Ren'Py library. Kana Mode has been
renamed to NVL Mode, and is now included in the commmon/ directory.
All of the other extras are now part of the cookbook section of the
web site.

We've unifed config. and library. variables. They are now all config
variables, with library being an alias to config.

Bar, Button, and Window are now documented as displayables.

Now, aborting a transition will abort all successive transitions until
the next non-transition interaction.

Rollback and Rollforward have been extended to support remembering
what the user did the first time he encountered an interaction. This
required changing ui.interact and renpy.checkpoint, and adding
renpy.roll_forward_info. The say, menu, pause, input, and imagemap
interactions all support this memory. Most notably, this means one can
roll forward at a menu, and automatically make the same choice as when
the menu was previously encountered.

DynamicDisplayable has been changed, to take a function as an
argument. This function returns a displayable and a time in seconds
for which the displayable is valid. (The old behavior is retained when
a string is passed in.)

SnowBlossom now takes a fast argument, which if true causes the
particles to start all at once all over the screen, rather then at the
top or the bottom only.

Character objects may be copied using the Character.copy method. This
method takes the same arguments as Character, with the values supplied
to the method taking precedence over those in the Character object. 

Character now takes a callback parameter, specifying a function that
will be called at various points during dialogue.

Ren'Py now attempts to automatically determine if the RLE optimization
will be profitable, and will automatically use the RLE optimization if
it deems it worthwhile.

Ren'Py now considers config.has_sound, config.has_music, and
config.has_voice when assigning mixer names to channels. If all of
these are set False, sound will be disabled. If only some are set,
only those mixers will control system volume.

Loaded python files are assumed to be UTF-8. This includes the
launcherinfo.py files loaded by the launcher. (Thanks to denzil for
reporting this one.)

The voice.rpy extra now plays the sample sound on the voice
channel. (Thanks to NetGenSuperstar for reporting this, and for
supplying the fix.)



New in Ren'Py 5.6.2
-------------------

The Ren'Py distribution has been reorganized, and now includes a
launcher program that lets one edit Ren'Py programs, and perform
common tasks with them. It also includes the SciTE text editor.


The rules for searching for the base directory have changed
slightly. The base directory may now be given as the first positional
argument on the command line. If that doesn't work, it defaults to the
directory containing the program used to launch Ren'Py.

The game directory search has also changed. If a --game directory is
given, then it is used relative to the current directory. (This is a
change from the current behavior.) Othewise, all extensions are
stripped from the program used to start Ren'Py. We first look for a
directory with this name in the base directory. If it's not found,
then we strip off everything before the first space or underscore, and
try again. We repeat this until we find the game directory, or until
we can't. We then try the "game" and "base" subdirectories of the base
directory. If those don't exist, we use the base directory as the game
directory.

We no longer change directory into the base directory. This means that
screenshots are written into the current directory, rather then the
base directory.


run_game.py has been updated with two functions intended for
customization by distributors. These functions control how Ren'Py
looks for the common directory, and for save directories.


The ui.imagebutton function has been modified to accept arbitrary
displayables, rather then just images. 


Exported wo new types of transitions. Pause is a transition that shows
the new image for a given number of seconds, while MultipleTransition
lets you combine multiple transitions into one.


Fixed a bug that made RLE images sometimes crash the system. Added a
rle argument to Image and other image manipulators.

Fixed a bug that prevented the factory argument to MoveTransition from
being accepted.

Fixed a bug that manifested itself in a crash when a clipped
Displayable was placed at (x, y) where x <= 0 and y <= 0.

Fixed a focus bug that made it difficult to unhide windows.


New in Ren'Py 5.6.1
-------------------

!!!
Fixed a bug that prevented image preloading from working.

Previously, in statements with a transition, focusable objects from
the old scene could be assigned the default focus. This is no longer
possible.

Auto-forward mode now takes into account the {fast} text tag.

The fullscreen image optimization now takes into account layer clipping.

Now, it is possible to load a save into a game with a changed list of
layers. 

After a load, the user can roll back the number of screens he could
before the load. Previously, this number was one less.

Prevented hang when executing a with statement without a prior shown
scene.

Improved the precision of bilinear scaling, which fixes artifacting
experienced with very small source surfaces.

Fixed a bug in the way python code was pre-compiled. This bug
manifested by "phantom syntax-errors", syntax errors that would occur
again the first time Ren'Py was started after they were first
eliminated. 

The Zoom function now checks its parameters, and will refuse to work
if they fall outside the source surface. (Previously, it would try to
work, and often segfault.)

A regression in fast skipping was fixed.

A regression involving PNG images with colorkey alpha has been
fixed. I didn't realize PNG images _could_ have colorkey alpha. Go
figure.

The mp3 decoder now supports id3v2 tags, but there are still a number of
mp3 files it refuses to support. We suggest reencoding them,
preferably to ogg vorbis.


New in Ren'Py 5.6.0
-------------------

The demo features new character art, contributed by Piroshki.


The syntax of the show, scene, and hide statements has been
expression. Along with image names, these statements also can take
image names and expressions evaluating displayables. So one can write:

show expression "foo.png"

to show foo.png, without having to declare an image. We have also
introduced an as clause that lets one specify the tag of an image, and
a zorder clause that lets you control the height of images inside a
layer. One can write:

show eileen happy zorder 2
show eileen vhappy as eileen2 zorder 1

This shows two eileen images, and it shows the second one below the
first. 

+++
As part of this, "as" and "zorder" are now Ren'Py keywords.


Ren'Py now includes a bilinear scaling feature. im.Scale, Zoom, and
the new FactorZoom function now use bilinear scaling by
default. FactorZoom and Zoom default to a very fast scaling method
that only works on opaque images, but this can be disabled usin their
opaque parameter.


A new documented minigame interface has been added to Ren'Py. This
interface allows programmers to write 2D minigames. These mingames
take advantage of Ren'Py's screen update management code. 


Character now takes two new parameters, show_side_image and
show_two_windows. These parameters take the place of the side_image
and two_window_say extras, which have been removed.


The default font has been changed to Deja Vu Sans. While the glyphs
shared with Vera Sans remain indentical, Deja Vu improves support for
Eastern European languages.


The new MultiPersistent object allows the storage of inter-game
persistent data.


The same inputs that hide transient windows can be used to show them
again.


Move, Pan, Motion, Zoom, and FactorZoom all take a time_warp
parameter, which allows a function to be provided that changes how
time is processed in those functions. This makes adding acceleration
and deceleration easy.


We now support layers that comprise a rectangle that is smaller then
the entire screen, through the config.layer_clipping variable.


Now, setting _window_during_transitions to True causes the narration
window to be displayed during transitions. 


Now, colors can be written in html-like hexadecimal notation strings, as well
as 4-tuples. When a displayable is needed, an image can be specified
by giving its filename as a string, and a solid color can be specified
by giving a color string beginning with '#'.


+++
When config.implicit_with_none is True (the new default), the
equivalent of a "with None" statement is run after each line of
dialogue, menu, renpy.input() and renpy.imagemap(). This allows for
transitions to be written as a single with statement, rather than a
"with None/with transition" pair.


+++
There are quite a few changes in styles. A big one is that we have
replaced the "selected_" styles, and replaced them with properties
beginning with "selected_". For example, instead of writing:

$ style.selected_button_text.hover_color = (255, 255, 0, 255)

we now write:

$ style.button_text.selected_hover_color = (255, 255, 0, 255)

Using the new hexidecimal string color notation, we could also write:

$ style.button_text.selected_hover_color = "#ffff00"

The old style names now are used in a compatibilty mode, but that mode
does not work with style inheritance. (So one can set
style.selected_button_text, but you can't inherit from the
selected_button_text style)

+++
We no longer support the activate_ style prefix, as it never
really worked. (We still support activate_sound, which did.)

All buttons used by the main and game menus inherit from menu_button
and menu_button_text. 

Now, style properties are checked to see if they are valid, and it is
an error to set a nonexistent style property. The
config.style_properies variable lets one define new style properties,
should it prove necessary. 


Ren'Py now tries to give an accurate line number for runtime errors in
python blocks found inside .rpy files.


Frame now takes a tile= parameter. When True, it will tile images
rather then scaling them.


There is now a im.Color image manipulator, which is similar to
im.Recolor, but takes colors as strings or tuples rather then
4 parameters. The im.Scale image manipulator is now documented. [doc]


The renpy.context_nesting_level function returns the depth of the
context we are in.  The renpy.count_displayables_in_layer returns the
number of displayables in a layer. The renpy.showing function can be
used to determine if an image tag is currently being shown on a layer.


When changing the script, Ren'Py now tries fairly hard to assign
statements the same internal name they had in the previous version of
the script. This means that it's now usually possible to load in a
changed script, and come back to roughly the spot where you left
off. (Previously, the closest we would come is the prior label.) Of
course, variables are given the values they when the game was saved.

This allows us to implement a new feature. Pressing shift+R when
config.developer is set saves the game, reloads the script from disk,
and then reloads the game. Doing this generally brings you to the last
unchanged line seen before saving, making it easy to edit the script
and then see your changes in action. Like many developer features,
this may not work perfectly in all circumstances.


Returning to the main menu no longer causes init code to be
re-run. This improves the speed of returning to the main menu, while
bringing its semantics inline with loading a game.


Ren'Py now checks, when parsing a file, that image statements are
contained within init blocks. It has long been an error to run an
image statement outside of an init block, so this primarily checks for
useless image statements.


Ren'Py is now more forgiving of whitespace on the last line of a
file.


We now look for the presplash image in the "game" and "data" directories,
as well as the directory derived from the script filename.

!!!
Fixed a bug that prevented pauses from terminating when they occured in
interactions beginning with a transition, when no events occured
during the interaction. A symptom of the bug was that if the user
moved the mouse, the pause would immediately terminate and the game
would advance.

!!!
A bug with MP3 playback on Windows has been resolved.



New in Ren'Py 5.5.4
-------------------

!!!
Fixed a use-after-free issue in the sound playback code.

!!!
Fixed a regression that caused the wrong menu choice to be focused.

There is now a new method of recoloring that allows one to specify two
colors, one of which replaces white and one which replaces
black. This is accessed through im.Twocolor. This effect can also be
applied to SFonts using the black_color style property. 

Now, the renpy.predict function can be called to programatically
predict an image.

Bars now support a vertical mode, in which the bar is laid out
vertically instead of horizontally. They also support an invert mode,
in which the value is represented by the right/top bar, rather then
the left/bottom one.

The renpy.show and renpy.hide functions now take string image names,
as well as tuples containing image names broken up into
components. The renpy.show function also takes a new parameter, what,
giving what will be shown (instead of looking it up as is usual).

There is a new side_image extra, that supports showing images to the
side of dialogue.

New in Ren'Py 5.5.3
-------------------

!!!
Fixed a bug in which some variables were not saved after the game was
restarted. This is a fairly major bug that could affect end users in
certain circumstances.

The reference manual has been updated to integrate changes that were
previously only in the wiki.

The renpy.with function (the equivalent of the with statement) now
takes a parameter, always, which controls if the transition should
always be executed.

The text layout algorithm has been made configurable. This will
probably not be documented, but will instead become a the basis of an
extra at sometime in the future.

There is now a confirm_quit label, which allows the user to customize
what happens when the user clicks the window close button.

There is now config.periodic_callback. If not None, this variable
should be a function that is called with no arguments at around 20hz. 

When config.developer is True, pressing the 'Y' key will dump a
description of the styles in the system to styles.txt.

Window and button backgrounds now participate in layout, using xpos,
xanchor, ypos, and yanchor.

There are now two new properties, xalign and yalign. Assigning to xalign
is equivalent to assigning the same value to xpos and xanchor, and
similarly for yalign. This means that it is now possible to write
xalign=0.5 to center a displayable, rather than having to write
xpos=0.5, xanchor=0.5.

A new optimization is that we only draw images that are above the
uppermost full-screen image that does not have an alpha channel.
Images below this image cannot be seen, and now are not drawn. This
optimization only considers the presence or absence of an alpha
channel, and not the content of that channel. So a PNG image with an
alpha channel that has full opacity will not trigger this
optimization, while the same image with the alpha channel removed will.

The renpy.pause function can now take a delay of 0. This will cause
the scene to display for exactly one frame. 

New in Ren'Py 5.5.2b
--------------------

Fixed bug in packaging.


New in Ren'Py 5.5.2a
--------------------

Fixed bug in lint.


New in Ren'Py 5.5.2
-------------------

+++
SFonts are now rendered in color. When a non-(255, 255, 255, 255)
color is supplied to a SFont, the supplied image is remapped so that
each channel has its value interpolated between 0 and the supplied
color. Most importantly, this means that white pixels will have the
supplied color. This functionality means that drop shadows are now
rendered correctly.

Fixed a bug that prevented Animations with long or no repeats from
functioning correctly.


New in Ren'Py 5.5.1
-------------------

Fixed a bug with clipping rectangle computations, when faced with an
image larger then the screen.

Added im.Flip, an image manipulator that allows images to be flipped
in a vertical or horizontal direction.

Fixed a longstanding bug in the DSE that prevented event.only and
event.solo from working.

The save_name variable can now be a unicode string.

Fixed the voice.rpy and kanamode.rpy extras to work with modern
versions of Ren'Py.

Added provisions for utf-8 characters in the window title, on
platforms that allow that.

There is now a new displayable, DynamicDisplayable, that executes an
expression upon each interaction and uses the result of that
expression as a displayable. 

There is now support for hypertext in Ren'Py, using the 
{a=argument}{/a} text tags. This support can be further controlled
using the config.hypertext_callback variable.


New in Ren'Py 5.5.0
-------------------

The library.script_version should be set to (5, 5, 0) to take
advantages of changes in this version.

The big feature of this release is the new Ren'Py default theme, which
can be enabled by calling theme.roundrect(). This theme can easily be
recolored. An alternate version of this theme can loaded by calling
theme.roundrect_red(). The call should be placed after
library.script_version and config.screen_width have been assigned to.

+++ 
config.with_callback has been changed. It now takes two arguments. The
first is the transition being performed. If this transition is a None
transition created as part of a scene, show, or hide statement, then
the second argument is the transition found in that
statement. Otherwise, it is None. config.with_callback is now requried
to return a transition, which replaces the specified
transition. Hopefully, this is enough to make with_callback useful, by
always giving the callback information specified by the user.

The list of characters used by SFonts was wrong, so that has been
fixed. The documentation has also been improved to include a
convenient list of what those fonts should look like.

Character has been updated to pass arguments beginning with show_ as
keyword arguments to its show_function and predict_function.

There is a new function, ui.frame(), which has been split off from
ui.window(). While both functions create a window, the default style
of frame is one that allows widgets to be placed atop it. (Whereas
ui.window() generates a window optimized for text.)

There is a new property, box_first_spacing, that if not None gives the
spacing between the first and second elements of a hbox or vbox. The
xfill and yfill properties also are now used by vboxes and hboxes. 

renpy.music.play and renpy.music.queue have been updated to take lists
of filenames as well as single filenames. If a list of filenames is
given, and loop is True, Ren'Py will loop through the list of
filenames, rather than a single filename.

Two variables, library.main_menu_music and library.game_menu_music
allow one to cause music to be played when in the main and game menus,
respectively.

By setting the library.always_has_joystick variable to True, one can
access the joystick menu even if no joystick is connected to the
computer. This enables a joystickless developer to customize the
joystick menu.

A bug that prevented music changed by a game menu from reverting back when
leaving the game menu has been fixed.

A bug that prevented a fixed click-to-continue indicator from working
has been fixed.

The screenshots taken with the 's' key are now PNGs, rather than BMPs.

There is a new image operation, im.Recolor, that can be used to
recolor each channel of an image.

A new config variable, config.sound, can be used to completely disable
the sound subsystem.

Fonts can now be read out of .rpa archives.

A number of styles have been renamed. The following are the style name
changes: 

  style.error_window -> style.error_root
  style.file_picker_window -> style.file_picker_frame
  style.file_picker_window_vbox -> style.file_picker_frame_vbox
  style.gm_nav_window -> style.gm_nav_frame
  style.gm_root_window -> style.gm_root
  style.joy_vbox -> style.js_frame_vbox
  style.joy_window -> style.js_frame
  style.joyfunc -> style.js_function
  style.joyfunc_label -> style.js_function_label
  style.joyprompt -> style.js_prompt
  style.joyprompt_label -> style.js_prompt_label
  style.mm_menu_window -> style.mm_menu_frame
  style.mm_menu_window_vbox -> style.mm_menu_frame_vbox
  style.mm_root_window -> style.mm_root
  style.prefs_pref -> style.prefs_pref_frame
  style.prefs_window -> style.prefs_frame
  style.yesno_window -> style.yesno_frame
  style.yesno_window_vbox -> style.yesno_frame_vbox

Basically, the purpose was to normalize styles with the frame vs
window distinction, and to normalize the abbreviation of joystick as
js. Previous style names will work for the forseeable future.


New in Ren'Py 5.4.5
-------------------

There is now a variable, library.script_version, that should be set by
all scripts to (5, 4, 5). While this variable isn't used yet, it will
be used by future version of Ren'Py (the 5.5/6 series) to ensure that
current scripts remain compatible with changes to Ren'Py proper.

Ren'Py now supports SFonts, which are image files containing character
images and separator information. Once SFonts are registered (using
renpy.register_sfont), they can be used any place TTF fonts can,
although they cannot be scaled, recolored, bolded, italiced, or
underlined automatically like TTF fonts. Despite this, SFonts have
some advantages. They are bitmapped fonts, with all the legal
advantages that implies (in the US). They also allow special effects
to be precomposed onto fonts, if necessary.

Ren'Py's implementation of SFonts is a new one, not borrowing from
other libraries. It supports the use of an arbitrary unicode character
set (defaulting to the usual ASCII-oriented SFont character set) and
kerning.

Slow text and skipping conflicted, in that when skipping one will see
the slow text effect. This may be a regression, but it's fixed now.

Properties can now be deleted from styles. Deleting a property from a
style allows it to be inherited from that style's parent, using the
usual inheritence rules.

There is now a function, ui.clear(), that clears out a layer. This
allows the ui functions to be used on non-transient layers, although
not all widgets may be used in this way.

Ren'Py now takes some new command line options. The --savedir option
allows the user to set the directory in which Ren'Py saves data
in. This allows Ren'Py games to be run from a non-writable directory.
The --version option prints the version of Ren'Py. The --compile
option causes Ren'Py to compile rpy files into rpyb files. 

There is now a variable, config.lint_hooks, that contains functions
that are called at lint time. 

A new extra, translations.py, gives all of the translatable strings in
the Ren'Py common code.

+++
Fixed a bug in renpy.music.set_music, in which the test was inverted
in the code. (But not in the documentation.) This may require a
script change if your game uses the undocumented behavior of that
button. 


New in Ren'Py 5.4.4
-------------------

Updated the gallery extra to support showing arbitrary displayables,
rather than just images with filenames. It was also updated to support
tuples, corresponding to composing one image atop another, and lists,
which display things in sequence. To support this, the tuples used by
gallery take a third argument which gives a filename which is used,
somewhat indirectly, to compute the thumbnail.

Clarified that the voice extra can take non-wave sound files, such as
OGG Vorbis and especially OGG Speex files. Also, made voice
automatically sustain through pauses.

Fixed a bug in Ren'Py that was causing the voice extra to
malfunction. The bug was caused by the contents of the config
namespace being copied at the wrong time, leading it to not be
restored properly to default values when Ren'Py was reset (as the Main
Menu choice.) 

Removed a leftover debugging statement that caused Ren'Py to spew out
all of the say statements in .rpy files it parsed.


New in Ren'Py 5.4.3
-------------------

The format of archive files has been changed, to store each media file
contiguously on disk. This allows us to use disk access to retrieve
files from archives, whereas previously the files had to be
reassembled in memory before use. Eliminating this memory assembly can
drop the resident size of Ren'Py significantly. (When music was
playing, there was a memory overhead equal to double the size of the
playing file... this has been eliminated.) While Ren'Py remains
compatible with the older-format archives, regenerating the archives
for a game allows it to take advantage of the new format.

RELEASING.txt has been updated and corrected.

Empty strings are now allowed in Say statements, although it's not
immediately obvious to me why they would be used, except in some
strange cases, or as placeholders.

The presence of tabs in a script causes a more appropriate error
message to be generated. Previously, they simply caused random parse
errors.

Fixed a bug preventing dump_text.bat and archiver.bat from working.

New in Ren'Py 5.4.2
-------------------

The renpy.display_say function was refactored into two functions,
renpy.display_say and renpy.show_display_say. In it's original
incarnation, display_say had been a simple function responsible for
showing dialogue to the user. Over the past few months, it has
accreted logic for click-to-continue and for slow text, among other
features. This made it hard to change the behavior of display_say, as
a function overriding it would have to implement all that logic
itself. 

To fix this, we've created a new function, renpy.show_display_say, and
made Character and display_say take a new parameter,
show_function. This function is now responsible for actually placing
widgets on the screen. It has a reasonably well-defined interface, to 
allow it to be overridden by user code in a way in which display_say
is no longer practically able to be.

+++
The two_window_say extra has been rewritten to take advantage of this
refactoring. To update, you'll need to copy over the new copy of
two_window_say. You'll then need to change Character objects with
the argument "function=two_window_say", to instead have the argument
"show_function=two_window_say". In return for this, features such as
pauses in text and slow text now work with two_window_say.

Ren'Py now displays dialogue shown via a rollback as quickly as
possible. This is a change from the previous behavior, which was to
show such dialogue at the speed set by the "Text Speed" preference.

The sound module has been rewritten to play sound (or silence) all the
time, rather than pausing and restarting sound playback as
necessary. This eliminates popping and errors in some edge cases, like
playing a very short sound.

Fixed a bug in the move transition that manifests itself if the move
transition is used while a transient is on the screen.

Fixed a bug that prevented ImageDissolves from working correctly on
big-ending platforms, like PowerPC-based Macs.

Fixed a bug that caused crashes with a presplash image on non-mac
computers.

New in Ren'Py 5.4.1
-------------------

Integrated the results of "Project Bardiche". This project aimed to
improve the cross-platform compatibility of Ren'Py by building it with
the same libraries, compiled with the same options, across all three
supported platforms. As a secondary goal, we will also make available
in a single bundle the source to all of these libraries, and a script
that can be called to build them all from scratch. 

The biggest user-visible change is that fonts are now rendered the
same on Linux and Windows. Previously, Linux fonts tended to be a
little less thick, which could lead to text being placed
differently. 

With this release, we also give the image and font file formats that
we officially support. We support PNG, JPG, GIF, BMP, and TGA images
(although the latter two are discouraged, due to a lack of
compression). We support TrueType fonts.

It is now possible to declare a Character with interact=False.

Made movies work more reliably on Windows and Mac. Movie() now takes
an fps argument, which specifies how many frames per second of the
movie to display. This gives the system some time to actually go and
render the movie itself.

!!!
Fixed a serious bug that caused Ren'Py to crash whenever a text speed
slower than 100% was selected.


New in Ren'Py 5.4.0
-------------------

This release introduces time correctness to the display subsystem of
Ren'Py. Previously, time was a kinda flexible concept in
Ren'Py. Objects were shown sometime before the first frame of an
interaction, and the frames that we drew represented a smear of time,
rather than some precise instant. This release changes that. Each
frame now represents a single instant in time, and the timebases for
things like animations, motions, and transitions all begin at the
instant of the first frame of the first interaction in which they are
present. 

We also have precisely defined two timebases that displayables can
use. The displayable timebase starts at the instant of the first frame
in which a given displayable was present, while the animation timebase
begins at the instant of the first frame in which an image with the
same tag is present. Having two timebases makes it easier to specify
what we want happening when, say, an animation is placed inside a
motion. Animations default to the animation timebase, while motions
default to the motion timebase, but both have an option
(anim_timebase) that lets you specify which timebases is wanted. For
example, one may want to switch a looping motion onto the animation
timebase if one wants to allow the character's expression to change
while the motion continues.

We've implemented a more precise timeout system in Ren'Py. Previously,
if we wanted to have an event occur at some time after a displayable
has been shown, we'd have to use use the 20hz periodic event and deal
with it as part of that. The meant that our best timing precision was
50ms, and often it was significantly worse (up to 100ms or so). Now, we
can schedule precise timeouts for event delivery, down to the ~10ms
range. Among other things, this allows for more accurate pauses, and
skipping to occur at a rate faster than the previous limit of 10
screens per second or so.

Integrated a Zoom function into Ren'Py. This function lets you zoom
into or out of an image.

renpy.music.play() now takes a if_changed parameter. If given as
True, and the music to be played is already playing, then the music
will not be stopped and restarted. Use this when you want to
immediately restart the music if and only if the music differs from
the currently playing music.

Added Fixed, HBox, and VBox functions to the script namespace. These
functions allow multiple displayables to be used when only a single
displayable is expected.

SnowBlossom now takes a start parameter, the value of which should be
an amount of time in seconds. The starting times of the various
particles are spread out over this amount of time.

The say and menu statements now supports unicode escapes. These should
be a \u followed by 1-4 hex digits, and are used to include a unicode
character. For example, \u00a0 will include the unicode NO-BREAK SPACE
character.

+++
We have changed the way placement of images work. Now, when used as
a widget, images and animations default to the same placement as
everything else (xpos=0, ypos=0, xanchor=0, yanchor=0). When used in
an image (shown with show or scene), the placement of other
displayables is now similar to that of an animation or image. The goal
of this change is to make more regular programming using the ui
functions, and the new semantics should lead to behavior that is
similar to the old semantics.

Fixed a bug that cause Animations and anim.Filmstrips to ignore
position properties supplied to them. Now, these object properly
respect position properties supplied to them.

!!!
Fixed a bug that caused Ren'Py to crash when attempting to predict
images from transitions associated with say or menu statements.

The screenshot key (s) now creates numbered screenshots.

Made some internal changes that allow us to integrate better with
libraries written in pygame, especially PGU. This could someday in the
future allow for maps written in PGU to be integrated into a Ren'Py
game. 
(http://www.imitationpickles.org/pgu/)


New in Ren'Py 5.3.3
-------------------

Implemented a particle animation system, which allows absurdly high
amounts of control of particles that are on the screen. It also allows
these particles to be created during the middle of the
interaction. The primary purpose of this Particles displayable is to
allow for things like snow and falling cherry blossom leaves. We also
have a special case constructor, SnowBlossom, that is intended for
snow, cherry blossoms, and rising bubbles.

Finally got around to defining which audio formats Ren'Py officially
supports. On the 3 platforms we produce binaries for, Ren'Py supports
WAV, MP3, OGG Vorbis, OGG Speex and MOD (Whatever formats ModPlug
supports, including MOD and XM). All these formats were tested on all
three platforms, and shown to work.

Implemented tight sound and music support. Tight sounds are sounds
that do not stop, but instead are expected to seamlessly blend with
the following sound or music segment. While these were supported in
prior versions of Ren'Py, there was an issue with fadeout. If a
fadeout occured near the end of a sound segment, the sound would
suddenly stop. While this isn't an issue with normal tracks, for
tracks involving tight loops this isn't desirable. Tight loop mode
makes fadeouts span tracks, making the fadeout sound correct. Tight
loop support only supports spanning a single track boundary, so the
fadeout should be shorter then a single track length.

Ren'Py now tracks which menu choices have been chosen by the user
(ever, in any game), and gives the choices that have been chosen at
least once the new styles menu_choice_chosen and
menu_choice_chosen_button. By changing some of the properties 
of these styles, it's possible to the user a distinction between
the choices the user has chosen once, and those the user has never
chosen.

Added a new function, anim.Filmstrip, that allows one to make an
animation out of an image containing a number of frames. 

A set type that participates in rollback has been made
available to user scripts. This type is named "set". The code that
supports seensets in menus has been modified to accept a set along
with a list. 

We now use modplug instead of mikmod. This fixes some problems with
mod playing that were caused by mikmod not really being able to safely
play two mods at the same time. (These problems occured even when
someone only played one mod at a time, due to the way in which Ren'Py
preloads sound files.)

We now compute the set of rectangles to blit to the screen more
precisely. If we have two non-overlapping updated areas of the screen,
we now blit them individually, where previously we blit the smallest
rectangle containing them both. (Which could be many times the size of
the two updates, if they were small and widely separated.) This change
makes particle animation more efficient.

Made lint report the number of words per screen of dialogue. Also,
made lint not throw Ren'Py into an infinite loop, fixing a
regression.

Fixed a problem in which animations were not showing their first
frame.

Worked around a bug in SDL that could cause popping in the case where
a sound file was being mixed in at a length that was not a multiple of
4 samples.

New in Ren'Py 5.3.2
-------------------

Joystick support now exposes Hold to Skip and Hide Text functionality
to the user. 

We now support the fading in of PCM (that is, non-MIDI) music and
sounds.

Fixed a regression in voice.rpy.

New in Ren'Py 5.3.1
-------------------

Ren'Py now includes support for using a joystick to play the game. To
configure joystick support, go into Preferences, click Advanced...,
and then click the function you wish to assign to a joystick axis or
button.

ImageDissolve now support a ramp parameter, which can be used to give
the ramp explicitly. 

Now, we preload the images that are used in say statement, menus, and
transitions. This means that just about every image in a basic game
should be preloaded, which should in turn lead to an improved user
experience and a lack of pauses for image loading. To support this,
the Character function grew a predict_function argument, and there are
now also predict_menu and predict_say functions at the
top-level.

Setting a config or library variable that does not exist is now an
now raises an error. Previously, this was ignored silently.

If it exists, renpy.zip is added to the python search path. This lets
one replace the renpy/ directory with a renpy.zip file containing that
directory, if so desired.

A non-nested return now returns the user to the main menu, rather than
dumping him out of Ren'Py entirely.

Fixed a bug that required Tab to be pressed twice to re-enable skip
mode after skipping was terminated by hitting a menu.

Maybe fixed a bug that was preventing non-fullscreen video from
working. (I'm not totally sure this is a real bug.)

Fixed a bug that prevents certain MOD files (including the .xm files
that shipped with the non-Ren'Py game Transfer Teacher) from working
under Ren'Py. This required the creation of a new Ren'Py Launcher for
Macintosh, as well as a new release of the renpy module installer for
Windows.

New in Ren'Py 5.3.0
-------------------

This changelog has been updated to flag changes requiring (or
suggesting) script updates, or providing major bug fixes.

!!!
Script compatibility has been broken, but for a good reason. The
previous version of Ren'Py stored python blocks in the script as bits
of python bytecode in the .rpyc file. This has a problem. Python
bytecode is not guaranteed to be forward or backwards
compatible. Without some sort of versioning, an upgrade of python
could cause these bytecodes to be silently interpreted incorrectly,
which could lead to games failing to work properly. To fix this,
several things have changed. The .rpyc files now store the python
script, rather than just the bytecode. The bytecode has been moved
into a bytecode.rpyb file, which is automatically created when a
script changes. This file contains versioned bytecode, and is
automatically regenerated if either the source code changes or the
version of python used to run Ren'Py changes. It is always generated
into the game directory. While it is possible to include bytecode.rpyb
into a .rpya file (under the same conditions as .rpyc files can be
added to .rpya files), realize that it may spring into existence in
the game directory automatically if the user tries to run Ren'Py with
a newer or older version of python. One should ship bytecode.rpyb as
part of a completed Ren'Py game.

There are now a few changes to Ren'Py to allow it to better support
scripts that are not games. Some of the internal messages have been
changed to remove the word "game". While "game" has still been left in
the most prominent places (the main and game menus), this is because
these places are the most obvious to the user, and hence the most
likely to be translated using library.translations.

For the same reason, Ren'Py will also search for the game in a data/
directory if the game/ directory is not found, and it will then look
for the game scripts in data.rpa along with game.rpa.

ImageDissolve now supports a number of different kinds of alpha
ramps. Along with the default linear, we now support cubic,
double-cubic, and mirrored-double-cubic ramp types. These types of
ramps allow for smoother or sharper ImageDissolve transtions. Thanks
go to shaja for contributing the code that implements this.

+++ 
Alpha channels are now supported on text colors. When rendering
text with a color or drop_shadow_color having an alpha that is not
255, that alpha is then used to scale the alpha channel of the drawn
text. This basically means that alpha is now respected in text, wheras
previously it was ignored. The default drop_shadow_color is now 
(0, 0, 0, 255), for compatibility with the way drop shadows were
rendered previously. If user code renders text with an alpha that is
not 255, the alpha should be set to 255 to ensure the text is rendered
the same way as before.

The DSE has been updated. There are now new event.only() and
event.choose_one() condition functions, and a basic guide to writing
events in the DSE can be found in extras/dse/EVENTS.txt.

Now, user code can import python modules from the game directory
and .rpa archives. A guide to using Python to extened Ren'Py can be
found in doc/EXTENDING.txt. For now, it's just about how to use
pygame code with Ren'Py.

Renamed extras/chinese.rpy to extras/east_asian.rpy, and changed the
line breaking algorithm to one that can be used with both Chinese and
Japanese text. It may also be usable with Korean, but I'm not sure
about that. 

Made the zero-width-space character break lines if necessary, so it
can be used to have auto-breaking with Thai.

All defined preferences are now found in library.all_preferences,
which provides a level of indirection when customizing the preferences
screens.

Now, we force the presplash to be shown using windib. This can fix
potential directx incompatibility bugs with Windows XP. This only is
an issue if a game has a presplash, the bug was fixed for regular code
in 5.1.1. The presplash is also shown faster now, before the rest of
Ren'Py loads.

Fixed a bug that affected voice. This required splitting
config.interact_callbacks into config.interact_callbacks and the new
config.start_interact_callbacks. The latter is called exactly once per
interaction, while the former is called whenever an interaction starts
or restarts.

Fixed a bug with non-ascii text and the new log feature.

Now, invoking Ren'Py with --profile on the command line does the same
thing as setting config.profile in the script, without requiring the
user to actually change the script.

Moved most of the code that used to be in run_game.py into
renpy/bootstrap.py (the renpy.bootstrap module.) This shouldn't really
affect anything, but it does make run_game.py a bit cleaner.


New in Ren'Py 5.2.1
-------------------

Added a command that allows the user to skip to the next
choice. Primarily intended for developers, this feature needs to be
enabled by setting config.fast_skipping to True before it can be
used. Once enabled, fast skipping can be activated by typing '>'. It
jumps the user to the next interaction that isn't a say, a transition,
or a call to renpy.pause()

Setting config.log to a filename will now cause a log of the user's
actions to be written to that filename.

Added (optional, and discouraged) monkeypatch protection through the
--lock command-line option.

Fixed a regression, introduced in 5.1.6, that prevented what_prefix
and what_suffix from working.


New in Ren'Py 5.2.0
-------------------

Restructured the distribution. All of the tools are now in the tools/
directory, while the dse has been moved to extras/dse, with a script
to launch it found in tools/.

Implemented a new warp feature. By supplying a filename and line
number, this feature tries to jump you to the statement preceding that
line. It isn't perfect, but for some games, this lets you have a live
preview of the game. Please see the reference manual for instructions on
how to invoke this, and a number of caveats.

Also implemented an editor feature. By pressing E (that's shift-e),
one can launch an editor at the location of the current statement in
the Ren'Py program. To enable this, one needs to set config.editor to
the command line for your favorite text editor. Again, see the
reference manual (for config.editor) for more details.

Implemented a new function, renpy.get_filename_line(), which returns
the filename and line number of the currently executing
statement. This can be used in conjunction with renpy.watch() to
constantly display the line number of the current statement.

Fixed a bug in the text widget that caused it to be sized incorrectly
in certain cases. Fixed an incorrect reference to a wav that became an
ogg in the demo. Modified renpy.watch() so that it coerces the result
of evaluating its argument to unicode, meaning it's no longer
necessary to manually do so.


New in Ren'Py 5.1.6
-------------------

Fixed Motion (the class that implements Move and Pan) to allow motions
to be used as transitions, in conjunction with the say and menu
statements. Previously, they only worked with the with statement.

Added a new variable, config.with_callback, that can be used to
specify a function that is called when a with statement runs. This can
be used, for example, to put up a window when a transition occurs,
which has the effect of preventing the window from disappearing.

Implemented a new text tag, {fast}. This tag causes the slow text
display to start from a given point in the text string. This allows
one to show some text, run some command, and show the same text with
additions, and have the slow text display occur correctly.

Character objects now can take properties prefixed with what_ or
window_. Properties prefixed with what_ are applied to the text being
spoken, while those prefixed with window_ are applied to the window
containing everything. Unprefixed properties are still applied to the
label giving the name of the character speaking.

There is now a new function, LiveComposite, that can composite
together arbitrary displayables, rather than just images. It has the
same API as im.Composite, but should be used when one of the things
you wish to composite is an animation.

A new variable, config.auto_choice_delay, has been added. If not None,
this variable gives a number of seconds that Ren'Py will pause at an
in-game menu before picking a random choice from that menu. We'd
expect this variable to always be set to None in released games, but
setting it to a number will allow for automated demonstrations of
games without much human interaction. 

The kanamode.rpy extra has been updated to support some of the newer
features, like slow text and auto-forward mode.

+++
Archives now combine the index and the data into a single file. Now,
instead of needing .rpa and .rpi files, only a .rpa file is needed
(and is created). The code and the archiver have been updated to
support this new format. The code still supports reading the old
format, for compatibility purposes. When archives are re-created, the
.rpi file can be deleted with no ill effects.

There is now a new function, renpy.block_rollback(), that prevents
Ren'Py from rolling back through the point at which it was called.

Renamed config.overlay_during_wait to config.overlay_during_with,
since the former name was a mistake.


New in Ren'Py 5.1.5
-------------------

There are now two new variables, library.main_menu_positions and
library.game_menu_positions. If not None, then we expect these
variables to be maps between main or game menu navigation button
labels, and properties that will be supplied to those buttons. This is
intended to allow the user to manually position the various
buttons. This shuts off the default positioning code, so if you
position one button in a menu, you'll need to position them all.

Added a new extra, menu_positions.rpy, that demonstrates the new
positioning code.

Added a new extra, quick_save.rpy, that adds a quick save feature to
Ren'Py. This feature adds a single save slot that can be quickly
accessed without going through the game menu. It also adds a quick
load button to the main menu, which causes a load from this slot. The
button is disabled if no quick save game exists.

+++
To support this, changed the format of library.main_menu. Now, instead
of being a list of pairs, library.main_menu is a list of triples. The
new third component is an expression, which must evaluate to true for
the menu button to be enabled.

Fixed a bug in lint that was caused by the introduction of the onlayer
clause in Ren'Py 5.1.3. This bug caused lint to fail entirely, so not
it works again.

Added raw string literals, although they're not a documented feature.


New in Ren'Py 5.1.4
-------------------

Implemented two new text tags, {w} and {p}. {w} pauses the display of
dialogue, waiting for the user to click to continue. {p} does the same
thing, but also breaks the line where it occurs. 

Added a framerate limiter. When enabled by setting config.framerate,
Ren'Py limits the number of frames that are displayed per second to
the supplied values. This tends to smooth out the framerate, and hence
the percieved smoothness of the program. It will lower the overall
framerate, but make it more regular.

Some improvements in the auto-forward mode. AFM will no longer dismiss
text when it is still being drawn onto the screen. (Because the text
speed is not infinite.) There is now also an AFM callback that can be
used to control if an auto-forward occurs. This is intended to be used
with the new renpy.sound.is_playing call, to prevent auto-forwarding
from occuring if when a voice is being played. I'm not bothering to
actually implement much of the voice functionality until someone
seriously proposes a voiced game, but I do want to add in the
infrastructure.

Increased the default rollback length back to 100, now that we have a
readback extra people can use if they want to. Updated readback so it
works a little better.

Updated LICENSE.txt, to point to a mirror site that contains the
source code for the LGPL libraries used in the various binary
distributions of Ren'Py.

New in Ren'Py 5.1.3
-------------------

The scene, show, and hide statements now take an onlayer clause, which
gives the layer that the operations occur on. So if we declare high to
be another layer (by setting config.layers to something like 
[ 'master', 'high', 'transient', 'overlay' ]), then one can use a
statement like "show eileen happy onlayer high" to show the given
image on the high layer. This image will not be removed when scene
statements clear other layers, such as the default master layer.

+++
To support the above, the parameters to renpy.show() changed in an
incompatible way. If your code uses renpy.show(), it will need to be
upgraded. Instead of considering the second and later parameters to be
at expressions, it now takes as its second parameter a list of all at
expressions. (This lets us use the third parameter to accept the layer
name.) 

The label 'after_load' is now called after a game is loaded, if it
exists on disk. This label can be used to upgrade save files, restore
music, and the like.

It's now possible to pick the screen the game menu enters when it is
invoked, by setting the _game_menu_screen variable.

Simplified the demo game script by moving the style stuff out of that
first init block, and down to the bottom of the script where it's out
of the way of a first viewing. Hopefully, this will reduce the shock
of someone first encountering Ren'Py.

Documented how to modify and replace the game and main menus, and how
to add in one's own preferences.


New in Ren'Py 5.1.2
-------------------

Ren'Py now supports embedding images inside text. Please read the
documentation of ui.text for some important caveats about how this
works, but basically, the input of ui.text can be a string or a list
containing strings and widgets. In the latter case, the widgets are
rendered inside the text. One can also use a text tag like
{image=filename.png} to include an image anywhere a text tag
works. One thing to realize is that images so included cannot be any
bigger then the text they are included with.

A new widget, anim.Blink, blinks a child widget in and out of
existence by varying its alpha channel.

Character now allows for the use of a click-to-continue widget when
the widget finishes showing text to the user. While many widgets can
be used, this feature is especially useful with Images, Animations,
and anim.Blink. The click-to-continue widget can be nestled in with
the end of the text, or placed at a fixed location on the screen.

Custom mouse support has been totaly rewritten. It now supports
animated mice, and changing the mouse cursor based on the kind of
interaction that is ongoing. Rather than describe the changes here,
read the documentation of config.mouse to understand the new
behavior. Please note that config.mouse has changed, and so if you use
it in your game (and AFAIK noone does), it will need to be modified.

Custom mouse support has also had significant performance
improvements.

Ren'Py can now read the script files out of an archive file. The
archive used can either be game.rpa and game.rpi, or name.rpa and
name.rpi, where name is the name of the file that is used to start
Ren'Py, with the extension and any prefix (before an including an
underscore) stripped off.

New in Ren'Py 5.1.1
-------------------

Fixed a bug that prevented the various day-planners from working, in
both the demo game and the DSE. (This was a bug in the game more so
then a bug in Ren'Py proper.)

!!!
Fixed a bug on Windows that manifested with DirectX under some
circumstances. We now use SDL's windib driver, which seems just as
fast for the software surface stuff we're doing.

Updated native midi support on the Mac, eliminating a non-obvious
race/locking problem. A new version of the Ren'Py launcher for
Macintosh comes with this release.

Removed the .rpyl files that were added in 5.1.0, as they wound up not
being needed after all.


New in Ren'Py 5.1.0
-------------------

+++
There is now a new sound system, supporting playing up to 8 mp3, ogg
vorbis, ogg speex, mod, or wav files at once. Midi can also be played,
but is limited to one midi file at a time. Audio files can be read out
of archives. Music and Sound now have their own mixers, which control
the system mixer. The low-level audio api has been ripped out and
replaced with new renpy.sound and renpy.music apis, which are somewhat
higher-level, and more flexible.

In order to support this, we've temporarily dropped Mac support. In a
few weeks, we'll be releasing a tool that restores and improves
Ren'Py's compatability with the Macintosh platform. To help support
this tool, this release includes .rpyl files for the demo game and
DSE.

The bar widget has been extended. It can now be adjusted by the user,
and it can show a thumb in the middle. Various volume and speed
preferences have been adjusted to take advantage of the new bar
widget.

All of the backgrounds in the demo-game script and in the reference
now are of the form "bg name". This lets one run a command 
"show bg newbg" to replace the background without replacing the
current screen. The demo game also has been prefixed with a UTF-8 BOM,
so editors should (hopefully) load and save it as UTF-8.

There is now a new font text tag. By writing {font=Font1,Font2}, one
can change the font in the middle of a block of text. Use this
wisely. Font files with extensions are now also searched for in the
system font directories, although we do not recommend this unless you
are having encoding problems.

Menu labels and choices support percent-substitution, like say
statements always have.

Now, all of the im image constructors take properties as
arguments. This lets placement properties be applied to images, as
with regular widgets.

A new extra, chinese.rpy, implements word-wrapping for the Chinese
language. Or at least tries to.

Fixed a bug which made the images created with im.Rotozoom
incompatible with im.Alpha.

Fixed a weird focus bug that manifested upon rollback when resized
frames were on the screen.

New in Ren'Py 5.0.1
-------------------

The hovered callback on buttons was no longer working. This is now
fixed. Also added a complementary unhovered callback. Documented them 
both on ui.button().

A number of changes have been made to Ren'Py, the cumulative effect of
which is to shrink the package size by a bit.

The python math module is now included with Ren'Py.

The presplash screen now displays without a titlebar.

Ren'Py now always runs internally in 24 or 32 bpp mode. It will still
run on a 16 bpp machine, but there will be a conversion from 32 -> 16
bits when it is displayed. This fixes a number of transitions that did
not work in 16 bit mode.

Fixed a bug with im.Size in which 800x600 was used as the default
target size, instead of the current screen size.

Fixed a bug that prevented drop_shadow = None from working.

New in Ren'Py 5.0
-----------------

Blessed 4.8.10 as the 5.0 stable release.

Minor changes to images in the demo game.

New in Ren'Py 4.8.10
--------------------

Added config.font_replacement_map, which is used to map from a regular
font to a version of that font that is specialized as italic, bold, or
both.

New in Ren'Py 4.8.9
-------------------

There is now a preference that controls skipping after choices. 

The new function renpy.choice_for_skipping should be called by user
code to indicate that a choice is occuring, and therefore we might
want to end skipping.

Fixed a bug that was preventing RevertableObjects from supporting
properties.

New in Ren'Py 4.8.8
-------------------

Auto-forward-mode has been implemented. It is controlled by its own
preference, which gives the number of seconds for which a given number
of characters is shown to the user. The number of characters is
configured by config.afm_characters, which defaults to 250. The number
of characters is determined by the length of the string shown to the
user with a number of bonus characters added to it. The number of
bonus characters is configurable in config.afm_bonus, which defaults
to 25. Auto-forward-mode can be hidden from the user by setting 
library.has_afm to False.

+++
The preferences screen has been redesigned, to have three
columns. Code that manipulates library.preferences may need to be adjusted.

Unicode support has been extended to names in the script. Now names in
the script can contain unicode characters, as well as ascii
characters. This includes labels and image names. Right now, we
consider all unicode characters to be alphabetic, so be sure to use
ASCII space where spaces are required.

New in Ren'Py 4.8.7
-------------------

The new DSE dating-sim engine code is now present in the dse/
directory. It's not documented, apart from the comments in the source
code, but it can be run by running the new run_dse program.

The image statement now passes its argument to the Image function,
in loose mode. This means that strings and tuples are turned into
single and composited images, respectively. So it's now possible to 
write:

init:
    image control room = "control_room.jpg"

instead of having to write:

init: 
    image control room = Image("control_room.jpg")

Of course, the old way still works.

There is now a new transition type, ImageDissolve. It lets us creat
dissolve transitions in which pixels are dissolved at different times,
which can be used for a range of effects. Two such effects are
'squares' and 'blinds'. A number of other types are defined in the
source of the demo game, in their own section.

A new im.Tile image operator has been introduced. This operator tiles
a source image until it reaches a specified size, or the size of the
screen if no size is specified.

Ren'Py now supports a presplash screen. If the file presplash.png is
present in the game directory, it is shown to the user on
startup. This occurs before any loading or initialization occurs, so
the size of the window it is shown in is determined by the size of the
presplash.png image itself. 

As per user request, we have made programmatic equivalents of the
image, scene, show, and hide statements available. These functions are
named renpy.image, renpy.scene, renpy.show, and renpy.hide,
respectively.

Ren'Py now supports a new classification of layer, top layers. Top
layers are layers that are displayed above any transition. This is
useful if you want to have an overlay that is shown even when a
transition is in progress. To have the overlays be displayed as a 
top_layer, remove the string 'overlay' from config.layers and append
it to config.top_layers.

A new config variable, config.enable_fast_dissolve, was
introduced. Setting this to False can fix a potential bug in the
dissolve transition when used with an overlay layer that has an alpha
channel that is not fully transparent or opaque, at the cost of 25% of
the performance of dissolve. It usually can be kept at True with no
ill effects.

Fade has been reimplemented in terms of Dissolve. This means that
fades will be as fast as dissolves. Fade now also can take a widget,
instead of a color, as an argument. If this widget is an Image, it
means that we will dissolve from the old screen to the image, hold at
the image for a given amount of time, and then dissolve from the image
to the new screen.

The ImageReference class is now documented and present in the game's
namespace. This lets us refer to an image by name from user code.

Added a RENPY_DISABLE_SOUND environment variable, which if set
disables support for sound in Ren'Py. (For use on platforms where
sound doesn't quite work.)

Fixed a bug in lint.

Fixed bugs that caused overlays to jump in and out during transitions,
restoring the pre-4.8 behavior.

The definitions found in common/definitions.rpy are now documented in
the reference. This gives a default set of transitions and positions,
as well as an image (black).


New in 4.8.6
------------

Ren'Py now takes a new option, --lint. (Or for those of you under
Windows, run lint.bat, editing it if necessary.) This option, when
supplied, causes Ren'Py to run checks for dozens of errors in the
script. Many of these checks test for problems that will only occur
at runtime, on platforms other than Windows, or when loading a
save-game after a change in script. This is the subtle stuff that my
script-review service was for... now it's automated, so you don't need
me anymore. 

Lint should be run before you release any game with Ren'Py, from now
on. In general, you should not release a game if lint gives you any
errors, but instead you should fix those errors first.

Lint also produces a count of the number of say statments and menus in
a program.

DynamicCharacter and Character have been unified into a single class,
such that now calling DynamicCharacter is equivalent to calling
Character with dynamic=True.

Character (and DynamicCharacter, and renpy.display_say) now take a new
argument, image. If this argument is set to True, then the name of the
character is interpreted as an image filename. This image is used
where the character's name would go, in place of a textual name.

Fixed a bug that prevented newlines from being recognized in text
widgets. (Introduced when I rewrote tokenizing in the previous
release.)

Fixed a bug in the _renpy module, in which we accidentally used the
height, rather than the width, of an image.

New in 4.8.5
------------

Added a new state-machine based animation function, anim.SMAnimation. 
This function creates animations by applying images and transitions
specified by the states and edges of a nondeterminstic state
machine. The result is that it's possible to specify complicated
random patterns of behavior. This can allow a character to blink
randomly, allow random backgrounds to be shown, and even allow things
to randomly move around the screen.

The SMAnimation framework can also be used to describe very
complicated, even nondeterministic, motions. This is done by declaring
a SMAnimation with None for the images, and then passing it in to the
at clause.

I should point out that despite the complexity of the interface, the S
and M in SMAnimation stand for state machine, and not anything
else. Honest.

All motions (Motion, Pan, Move, and anim.SMAnimation when used as a
motion) can now be used as transitions, in which case the motion is
applied to the screen (or layer, as appropriate). This let us put
together two new transitions, hpunch and vpunch, which shake the
screen horizontally and vertically, as appropriate. Useful for when
the POV character gets punched by a particularly feisty girl.

There are now two new image operators. im.Map can map the pixels
values in an image to different values. Using this, one can adjust the
colors of an image. The im.Alpha function is built on top of this, and
allows one to alter the alpha of an image. (It even adjusts a
pre-existing alpha channel.)

The definitions of transitions and placements, which were once in
script.rpy, have been moved into common/definitions.rpy. 

There is now a new config variable, config.text_tokenizer. This
variable is used to give a function that breaks a line of text up into
words, spaces, and other things. Providing a custom function here
allows for control of where line breaking is allowed, useful for
languages that have different rules about that.

Fixed the gallery.rpy extra, so that it now works properly with the
main menu being in a menu context. 

The demo game was updated to demonstrate the new feature, as well as
to have a new, drop-shadowed window frame.

New in 4.8.4
------------

The format of the compiled script (.rpyc) files has changed. The new
format is more efficent, both in terms of space and memory. 
Unfortunately, the format change is not backwards compatible,
and the automatic upgrade function probably won't work. So you'll need
to delete the rpyc files from the game directory when you copy it
over.

Removed some unnecessary conversion from pixellate, improving its
performance when running on a computer with 32 bits per pixel
graphics. 

The xanchor and yanchor arguments can now take numbers between 0 and 1
as well as names. Functions returned by Motion now can either return
an xpos, ypos tuple or a xpos, ypos, xanchor, yanchor tuple. Move has
been upgraded so that it can take similar tuples as the start and
end arguments, letting us interpolate the location of the anchors
while moving an image around.

The above modification allowed us to implement a new move
transition. This transition attempts to find images that are present
in both the old and new scenes, but have changed location between the
two scenes. Such images are moved from the old location to the new
location over the duration of the move transition. This makes it easy
to smoothly move characters from one location to another on the
screen.

The demo script was updated and reorganized, to demonstrate more
features. Now, all transitions are demonstrated, as well as things
like renpy.input, DynamicCharacter, Move, and Pan.

A slightly updated version of the script for Moonlight Walks is now
in the scripts/ directory. It's there as an example for people to
learn from. This script has been updated to work with Ren'Py 4.8, and
to fix a tense error.

!!!
Fixed another segfault in windows native midi support.


New in 4.8.3
------------

!!!
Ren'Py no longer uses the psyco specializing compiler. The relatively
small (about 2%) speed increase it gave wasn't worth the hassle
involved in dealing with memory leaks and other semantic changes. This
change significantly lowers Ren'Py's memory usage, and fixes a major
memory leak that was introduced in the 4.8 series.

!!!
A number of race conditions were fixed in the windows native midi
code. The upshot of this is that we can now play midi on windows
without there being a small chance of crashing each time we start a
new track.

+++
The config.music_interact variable is gone. It's been replaced by
config.interact_callbacks, which is a list of functions to call before
each interaction. (This will help us support voice.)

A new Motion function allows the user to give a function that controls
how a displayable moves on the screen, allowing for customizable
motions. Pan and Move have been reimplemented in terms of Motion. All
three functions now take repeat and bounce parameters. Repeat causes
the motion to repeat after a single period is over, while bounce
causes the motion to bounce from extreme to extreme.

Finally, a new voice extra has been added as extras/voice.rpy. This is
a simplified version of what will eventually be Ren'Py's voice
system. Right now, the only feature missing is that voices for
characters cannot be enabled or disabled individually, but may
instead only be manipulated in the aggregate.


New in 4.8.2a
-------------

!!!
Clicking preferences on the main menu jumpled to an undefined
label. This is now fixed.

A new extra has been added. The commentary.rpy extra adds an optional
commentary window, which is shown only when the commentary preference
it adds is enabled.

To support the above, statements are only marked as seen if they have
actually been shown to the user (by ui.interact being called during
the statement.)


New in 4.8.2
------------

Unicode support in python blocks now works. This allows unicode
strings to be used with Ren'Py. This is especially useful when naming
characters and translating the various menus into your native
language. Please note that the only unicode allowed is inside unicode
strings, which begin with a u before the first quote. Unicode outside
of unicode strings is an error.

We apologize to the non-english-speaking world for not noticing this
one sooner.

+++
The main menu was moved out of the context that the main body of the
game code executes in, into its own context. The only effect this
should have on user code is that some of the menu options changed from
simple label names into more complicated jumps. But it does allow us
to share the main menu with the game menu, which is something I've
had requests for. 

A number of minor changes were made to the menu at this time.

The README_RENPY.txt file was updated, to make it more current and
useful.

The Character and DynamicCharacter objects were updated to take a
condition argument. If this argument does not evaluate to true when a
line of dialogue is executed, the line is not displayed to the user.

A new extra was added (in two_window_say.rpy) that places the name of
a speaking character, and what they are saying, in two windows
that can be styled separately. 

The biggest change in Ren'Py was the addition of the _renpy
module. This is a C module that enhances the functionality of pygame,
allowing us to provide transitions and apply effects that simply
weren't possible before. A compiled version ships with the windows
binaries, installers are available for windows and mac from the Ren'PY
website, and source is included in the module/ directory to compile it
under Linux and Unix.

The presence of the _renpy module allows for two new features. The
first is that the thumbnails of save images are now smoothly scaled
down, which improves their look quite a bit.

The second new feature is the new pixellate transition, which
pixellates the old screen, swaps pixellated screens, and then
depixellates the new screen. One can see this feature in action by
right clicking to access the game menu... for this release, we've set
the game menu transition to be pixellate.


New in 4.8.1
------------

Character objects are no longer limited to displaying through
renpy.display_say, but can now be supplied a function argument, which
is a function that is called instead. This will make it easier to
radically change how dialogue is displayed.

The ui.grid object now has a new argument, transpose, which allows 
widgets to be added down the columns first. It also is smarter about
allocating space to subwidgets when xfill or yfill are set.

+++
The file entries in the load and save screens are now arrainged in a
grid, which has the style file_picker_grid. This means that we should
now be smarter in the presence of games of varying size, and we should
wrap text if it gets too long. As part of this,
library.file_page_length has now been broken out into two variables,
library.file_page_rows and library.file_page_cols.

renpy.music_stop now supports a fadeout parameter, for orthogonality
with the new renpy.music_start. 

Now, python blocks have the correct filename and line numbers
annotated onto them. This means that tracebacks generated in python
blocks will show a .rpy file and the appropriate line, rather than
showing "<none>" and a random line as they did before.

There are two new style properties, xmaximum and ymaximum. These two
properties limit the size of the widgets that they are applied to, as
if that widget was placed inside a ui.sizer(). (In fact, ui.sizer() is
now implemented in terms of these properties.) 

!!!
Now, we only restore or rollback to places where all of the transient
layers are empty. This prevents a bug in which additional dialogue
will be lost when a restore or rollback occurs. 

+++
The way in which preferences are displayed has been made more
configurable. Now, there is a new variable, library.preferences, which
is a map from a style to a list of preferences to be displayed in a
vbox with that style. There are now two new styles (prefs_left and
prefs_right) which control the placement of the default preference 
columns.

There is a new spinner preference type, which allows a value to be 
incremented or decremented. This preference is now used to adjust the
speed at which text is shown to the user. So now this is controlled by
the user, rather than the config.annoying_text_cps parameter. If you
don't want to give the user this control, you can set library.has_cps
to False. A number of new styles define the spinner.

An empty string is now rendered as if it was a string consisting of a
single space. This fixes a bug in which an empty string was rendered
with zero width and height.

New in 4.8
----------

A new system was implemented to manage widget focus. This new system
allows the focus to be moved from widget to widget using the keyboard,
without requiring the keymouse behavior be used. Because of this new
system, the keymouse behavior is now a no-op. 

+++
To simplify the code and make every widget compatible with the new
focus code, a number of widgets were reimplemented in terms of
buttons. This includes the ui.menu widget, which is the widget that is
used when presenting the user with choices. Menu buttons are of the
new style style.menu_choice_button, while their labels remain of style
style.menu_choice. Background images and padding can now be styled 
onto these menu buttons.

A number of new image manipulators have been made available in the
new im package. These are objects that can load an image (im.Image), 
crop an image (im.Crop), scale images (im.Scale), rotozoom images
(im.Rotozoom) and composite images (im.Composite). The latter is much
more flexible than the previous image composition system, as it now
supports placing images at arbitrary locations on an arbitrarily big 
canvas. Image (by itself) is now a function that creates the
appropriate image manipulators, retaining compatibility with its
behavior in previous releases.

The image cache is now based on image size, rather than number of
images. This prevents a large number of small images from filling up
the cache.

We now load images before starting the timer for a transition. This
prevents us from popping into the middle of a transition because we
spent some time loading images. This behavior can be controlled by 
config.load_before_transition.

The ui.imagemap widget has been rewritten in terms of ui.imagebuttons
and im.Crops. Some styles have changed names as a result.

Ren'Py now keeps track of the images that have been shown to the
user. This is the basis of this release's new extra, gallery.rpy,
which manages a gallery of unlockable CG.

The audio system has been rewritten, and a number of low-level audio
functions have been exposed in the new audio file. These functions
control audio directly, but do not save the state of audio in a save
file. The high-level music functions have been rewritten and placed in
the music.rpy file, allowing a sufficently adventurous game author to
change the way music is played. 

Two changes have been made to the renpy.music_start() function in the
high-level sound api. The startpos argument was removed (as it was a
pain to support), and a new fadeout argument was added, which lets the
fadeout time be controlled for each new song that is played.

The low-level sound api now lets us do the following things:

[list][*] Play up to eight sound effects at once.
[*] Cancel a playing sound effect.
[*] Pause and unpause the playing music.
[/list]

There is now a new, state that a widget can be in. Along with hover,
idle, and activate, a widget can now be insensitive. This is the state
that all non-focused widgets are in. Having the new insensitive state
means that we can eliminate the various disabled_button styles, so we
did.

In general, in this release, many styles have changed names.

In prior versions of Ren'Py, the bar widget could respond to
clicks. This was never used, and won't work well with the
keyboard focus control system. So, it's been eliminated.

Now, if the label "enter_game_menu" exists, it is called when entering
the game menu. It's expected that the main purpose of this label will 
be to play music when in the game menu. Using the default music
system, the code to do this would look like:

[code]
label enter_game_menu:
    $ renpy.music_start("game_menu_music.mid")
    return
[/code]    

A number of bugs were fixed, including bugs with the style system, and
with animation refresh.

Tab characters are now expanded to tab stop at eight spaces, rather
than to a fixed spacing of eight spaces. Old code using tabs may need
to be reformatted. 

The 'h' key now hides the windows on the screen. This means that all
Ren'Py functionality is now available through the keyboard, at least
for people with a 1-button mouse. (cough ... Mac ... cough)

Finally, setting the environment variable RENPY_DISABLE_FULLSCREEN to
a non-empty value will disable fullscreen support, for those people
(that person?) who had it crash their systems.


New in 4.7.2
------------

This release should be compatiable with the .rpyc and .save files
produced by 4.7.1.

!!!
The new readback extra caused save files to reach a size and/or
complexity that caused errors in cPickle on Windows, which in turn
lead to a repeatable crash of Ren'Py, and left a corrupt save file in
the saves directory that prevented further saving and loading of
games. This has been addressed in two ways. The first is the use of
pickle (as opposed to cPickle) throught Ren'Py, a change that may slow
down the engine a little but should ensure correctness. The second is
that we now catch the errors produced by corrupt files, and (if
config.debug is not set) proceed by ignoring that file.

There is now a new extra, readback.rpy. This implements readback, in
addition to, or instead of, rollback. Readback is limited in a number
of ways, insofar as it only shows text without changing pictures or
other things. As part of implementing readback, we added a new
function, say, that is called when the user gives dialogue consisting
of a pair of strings.

There are a number of changes that improve support of the Mac OS X
platform. The foremost among them is that we ship a new file,
run_game.pyw. This is identical to run_game.py, but is necessary for
the game to run in a graphical environment on the Mac. (It also will
run the game without a console window on Windows, if you have the
appropriate dependencies.)  Ren'Py still requires that PyObjC and
pygame are installed on a OS X 10.3 box before it can run.

The way font line spacing is computed was changed in this release, in
the hope of making it consistent on all three platforms. We now ignore
font linesize hints, which seem to be computed incorrectly on some
platforms, and instead set the line spacing to be equal to the ascent
and descent of the font. The user can increase or decrease the line
spacing by setting the new line_spacing text property. The old
line_height_fudge property is now ignored. The style.rpy common file
was updated to take account of this change.

To aid the user in finding the source of error messages, we now report
the name of the file being parsed when an error occurs during the
parse phase.

The tutorial has now been renamed "The Ren'Py Reference Manual", as
it's really more of a poorly-organized comprehensive reference then a
tutorial. This is in the hope that the Ren'Py user community will one
day write a more reasonable tutorial. A number of errors in the
reference were corrected.

The functions used in keymaps can now return values, which are
returned to the ui.interact() that called them. This was needed 
to support readback.

LICENSE.txt has been updated to include the names and URLs of software
that a windows build of Ren'Py depends on, the licenses of which you
will be required to comply with when releasing a Ren'Py game.

New in 4.7.1
------------

Added a new tool, dump_text.py/.exe, that dumps all of the text from a
Ren'Py script file. It uses a heuristic approach that is imperfect,
but is hopefully accurate enough to be useful for purposes like
spell-checking a script. The text is dumped into the file text.txt in
the current directory, and on windows that file is then displayed to
the user. By default all of the rpy files in the game directory are
displayed, but supplying a filename parameter can change that.

Fixed a bug that was preventing parser error messages from being
reported on Windows.

Fixed a bug in Render.subsurface that lead to weird effects when doing
an irisin or irisout on a sufficently complicated scene. See
http://lemmasoft.renai.us/forums/viewtopic.php?p=4612#4612 for the
discussion. 

New in 4.7
----------

The demo was updated to show the new features in 4.7.

The big new feature in this release is text tags. Text tags is a
markup language that allows text properties to be changed inside a
single unit of text. It lets you emphasize individual words by making
them bold, bigger, or a different color. Rather than explaining it
fully here, let me point you to the new "Text Tags" section of the
documentation. 

There were two changes that were made to Ren'Py to support text
tags. The first was that interpolation now quotes the interpolated
text, making it impossible to introduce a text tag via interpolation. 

The second change is that renpy.input() and friends now take as
arguments strings giving allowed and excluded characters. The default
is to exclude the '{' and '}' characters, meaning that it's impossible
for a user to input a text tag. 

Finally, this release features even more defensive programming
involving sound. Now, if the mixer does not initialize, no further
sound operations will be performed.

New in 4.6.2
------------

4.6.2 was never officially released, as it didn't cure all of the
sound woes, and didn't have much else in the way of new features.

Added a speed test, which tests the speed of the dissolve transition
on a user's system. This test can be accessed by typing 'S' during the
demo (that's shift+the 's' key). 

Fixed a bug with sound on systems with no soundcard in them. (Also,
put in a note to remind myself not to re-introduce that bug.)

Fixed a bug in which imagemaps would not redraw properly.

New in 4.6.1
------------

Fixed a major memory leak in the rendering code. This leak was
rendering 4.6 and 4.5 unusable on smaller systems.

Executed 250,000 statements (well, 5 statements in a loop, while
skipping), and ensured that there was no memory leak during the 
execution of these statements.

Added a memory profiler. You can see it by supplying the --leak option
to run_game.exe or .py, but don't expect to understand it.

Changed Dissolve so that it tries to use compositing when it can. This
means that it only draws to the screen once... which is a little bit
of a speedup on a really expensive operation.

Fixed a bug that was preventing predictive image loading from
working. 

New in 4.6
----------

The demo was updated to show some of the new features listed below.

There's now a third state that hovered widgets can go into. The
activate state is enabled when a button is clicked or a menu choice is
selected. The activate state can only be seen when a transition occurs
immediately after a button is clicked or a menu choice is selected.

The margin and padding properties have been broken up, so it's now
possible to specify margin and padding for the left, right, top, and
bottom of a windows. 

The biggest internal change in this version is the introduction of a
layer system in Ren'Py. Transitions can now work on an individual
layer (as well as the previous behavior of the whole screen), so it's
possible to do things like sliding in and out the dialogue box. 

It's now possible to use transitions when entering and leaving the
game menu, by assigning a transition object to
library.enter_transition and library.exit_transition, respectively.

The preferences screen can now be entered from user code, and is 
now part of the main menu.

Character objects now support an interact argument when called
directly. If it's False, then no interaction occurs. This lets a
character window become part of a larger screen.

Two new extras have been added:

[list]
[*] button_menu.rpy changes the way menus are displayed. Each menu
choice is displayed in its own button, roughly centered on the
screen. A single menu caption is displayed as narration, if such 
a caption exists.

[*] overlay_menu.rpy changes the behavior of right click from 
showing the game menu to showing a bank of buttons that, when 
clicked, bring the user to the game menu.
[/list]

The overlay code was overhauled. It's now not possible for an overlay
function to return a list of widgets. Instead, the overlay functions
are expected to add widgets to the screen using the ui
functions. Calling the new function renpy.restart_interaction will,
among other things, cause the overlay functions to be called again, if
one wants to replace the overlay on the screen.

A new variable, config.overlay_during_wait, controls if overlays are
shown during the execution of wait statements.

Init blocks of the same priority are now assured to run in the order
that they appear in a script file.

The renpy.interact() function has been eliminated. Use ui.interact()
instead, as it performs more error checking.

Fixed a bug in which some redraws were ignored, and another in which
the input widget failed to eat characters. (So typing 'f' in an input
widget would be passed through, and eventually cause the game to go to
fullscreen mode. No longer.)

4.5's demo script had a bug that cause it to crash, after playing the
MPEG-1 movie. It was a bug in the demo script, and not in Ren'Py
proper. It's fixed.

New in 4.5
----------

We now ship an extras directory, with interesting sample code. It
includes: 

[list]
[*] fullscreen.rpy, containing code to automatically switch the game
into fullscreen on the first run, while preserving the user's
preference on later runs.

[*] 640x480.rpy, which shows how to customize Ren'Py for a game that
runs at 640x480.

[*] kanamode.rpy, contains the code to emulate the interface of the 
various Digital Object games, which display text one line at a 
time, but keep a page of text on the screen at once. 
([url=http://www.bishoujo.us/hosted/kanamode.jpg]screenshot[/url])
[/list]

Added a new CropMove transition. This single class is the root of not
one, not two, but fourteen transitions, in the forms of wipes, slides,
slideaways, and rectangular irises. You can see some of these
transitions in action in the demo, which now has a new section, 
"What's new with Ren'Py?"

Added support for playing MPEG-1 movies. Rather than explain it all
here, we'l just mention that you can read the new "Movies" subsection
of the "Multimedia: Sound, Music, and Movies" section of the Ren'Py
manual. We support both hardware-accelerated full-window movies and
using a movie as a widget. This is also shown in the what's new
section of Ren'Py.

Added ui.grid(). This is a widget that places its children in a grid.
The children must have sizes that do not consider the amount of space
available for the grid to work.

Added ui.pausebehavior(). This separates pausing from the saybehavior
paving the way for uninterruptable pauses (a bad idea, IMO) and menus
that dismiss themseleves after a certain amount of time.

A new function, renpy.exists(), can check to see if a given file can
be found in the searchpath. This could be used, for example, to make a
game that only tries to play music if an add-on music package is
downloaded, and the files placed in the appropriate place.

Added the ability to bind mouse events to mouseup as well as
mousedown, and changed some of the default bindings to be on mouseup
rather than mousedown. If you make changes to config.keymaps, you'll
need to change mouse_1 to mousedown_1, and so on for various other
button numbers. 

Moved the place we look for menu sounds from the style of the choices
in the menu to the style of the menu itself, as that seems more
rational. Also, gave menus their own style. (Can't believe I forgot
that.)

Made a few changes to the library screens. First of all, we
rationalized (to some extent, it's still pretty ugly) the names of the
styles for library widgets. So some of that may have changed. We
placed preferences and the yes/no dialogue inside windows, which can
be styled by the user. We then routed all button and label creation
through two functions, _button_factory and _label_factory. By
overriding these functions, the user can (for example) replace the
default textbuttons with imagebuttons.

Made 'f' toggle fullscreen at the main menu. This will help on virtual
windows, where the mouse doesn't work right in fullscreen mode.

Improved rendering speed. Now, we aggressively cache things to
minimize re-renders, and only draw to the screen the parts of the
screen that have changed. In common cases, such as the case where only
some text has changed, this can greately improve performance. In other
cases (transitions), we have to redraw the entire screen anyway, so
there's little improvement.

Fixed a bug in which hiding the UI was not working properly. (This 
broke the center mouse button behavior.)

New in 4.4.2
------------

Improved the configurability of the say and menu statements, also
changing the way they work. Say statements without a speaker specified
are routed through the narrator character, while all menu statements
are routed through the menu function. Customizing these functions can
customize how Ren'Py interacts with the user, making it a much more
flexible engine.

As part of this, we changed the way character objects work. They are
now called directly to display dialogue, rather than having the say
method called on them.

If your game uses variables named "narrator" or "menu", you will need
to rename them.

Changed the way spaces are handled by the text widget. Specifically,
they are no longer merged, so it's possible to include spaces in
dialogue and thoughts. Please note that the parser still merges
adjacent spaces, unless you escape them with a backslash.

Added a new widget, ui.sizer, that can shrink the amount of space
allocated to its child.

Added two new text properties, first_indent and rest_indent. These
properties control how many pixels of indentation to put before each
line of text. 

Added a function, color, that can translate a hex triple or quadruple
into a Ren'Py color.

New in 4.4.1
------------

4.4.1 is being released to test some sound fixes, and so it isn't
really isn't that complete or well-tested.

Fixed some longstanding bugs with midi music on Windows. First of all,
we now ship with the 1.2.6 version of SDL_mixer, which fixes a bug in
1.2.5. That bug caused panning to go to the hard left. We also try to
read the windows midi device volumes, and set our volume to match the
first one we can read. This should prevent really loud midi music from
happening.

Also, increased the size of the sound buffer to 4096 samples, to
prevent skipping.

Some new features:

Now, adding interact=False to a Character object will prevent an
interaction from occuring.

Implemented functions to get the amount of time elapsed during the
game, renpy.clear_game_runtime() and renpy.get_game_runtime(). 


New in 4.4
----------

Added a number of features to allow Ren'Py to support statistics-based
dating simulations. The first is a new ui.bar() widget, which allows
the display of a bar graph. The demo has been enhanced to include a
stats and schedule screen, to show how this could be used. You can get
to it by asking how to write your own games in the demo, or you can
follow the below link to get a screenshot.

[url]http://www.bishoujo.us/hosted/screenshot.jpg[/url]

Another feature that has been added were 'jump expression' and 'call
expression' statements, allowing computed jumps and calls. Together
with an imporoved scheduler and yet-to-be written event dispatcher,
this provides the foundation for SBDSes. 

Now, setting a property on a style also sets the hover_ and idle_
variants of that property. This makes changing a property of an
inherited style a bit saner. In addition, hover now propagates to all
children of a button. This means that hover will now work with the
styles in the file chooser.

Added support for layering images. This support (invoked by passing a
tuple as an image filename) allows a single image to be constructed
from multiple image files, saving disk space while still keeping
performance.

Improved skipping. Now, along with control causing skipping of seen
dialogue, TAB toggles skip mode. An indicator displays to let you know
that skip mode is enabled. Finally, if a game author wants to disable
skipping, he can set config.allow_skipping to false. 

(The following were also in 4.3.2, which was a private release to
test the fixes for UTF-8 support.)

There were two bugs with UTF-8 support. The first was that we didn't
understand the byte-order mark, and choked on the syntax error. The
second was that the error-reporting code wasn't passing unicode errors
through properly, so one couldn't even see the real error. Both are
now fixed.

Improved the reporting of errors that occur during script loading and
interpreter initialization by no longer giving a line number when none
is appropriate.

Ren'Py now uses the name of the executable to choose the directory to
read the script from. It does this by looking at the name of the
executable that was used to run Ren'Py. It strips off the extension,
and anything preceding the first underscore in the name, if such a
thing exists. It then looks to see if that directory exists, and if it
does, uses it. For example, if the program is named "run_en.exe", the
"en" directory is used, while if the program is named "homestay.exe",
the directory "homestay" is used.

The config variable config.searchpath is a list of directory that are
searched for image files and other media (but not scripts, since all
scripts are loaded before the variable can be set). This allows
multiple game directories to share images, music, and other data files.

Once again, I redid the file chooser and default styles. The new file
chooser displays 10 entries in two columns, with each entry being
shown with an image. The files are now orginized into numbered slots,
and it's possible to save in a slot without saving in all previous
slots. There were also some changes to the non-user-visible parts of
loading and saving.

Speed Enhancements:

We now precompile python blocks in Ren'Py scripts, and store the
compiled code in the .rpyc files. This makes loading an unmodified
script significantly faster. On my system, this more than halved the
time it took for the demo script to load. On the dowside, when a
script is changed, it now can take somewhat longer for it to begin
running, as all the changed code needs to be recompiled. Overall,
it's a win, provided you ship the .rpyc files to your users.

Did another round of profiling, and found that styles were
significanly slowing the system down. So I rewrote them to be much
faster. This change shouldn't be user-visible, except that your game
will feel a bit peppier.

Added a 1-entry cache for solid fill surfaces. If your game uses them,
this might make it go faster. 

New in 4.3.1
------------

New, but undocumented, in 4.3 was the console.exe windows binary. This
is a windows executable that opens a windows console. This could be
useful if one wants to have a script that prints debugging information
to standard output, as in:

[code]
$ a = 1
$ print "a =", a
[/code]

There is now a new style property, enable_hover. This must be set to
True for a widget to respond to hovering by changing its
style. However, if it's set to False, no style change/redraw occurs,
making Ren'Py snappier. It defaults to True.

Ren'Py is now built with psyco, the python specializing compiler. This
makes program startup a bit slower, but in return the running time
once it's loaded should be faster.

A new config variable, config.window_icon, allows the user to specify
an image file to use for the window icon. Counterintuitively, this
should probably be a PNG, as the ICO format is not supported by the
SDL_image library.

Game menu navigations and preference buttons now have their own
styles, allowing their look to be customized.

A bug that prevented the reloading of persistent data on windows has
been fixed.

New in 4.3
----------

Now, when the library first starts up, it tries calling the
"splashscreen" label, if it exists. The splashscreen will not be
called in the case of a full reset (known to the user as a return to
the main menu).

Added a new text property, antialias, that controls the antialiasing
of text. Also made the font property optionally take a comma-separated
list of font names, which are searched for in the 

Added a new class, DynamicCharacter, which is now the preferred way of
having a character with a changable and/or user-input name.

A new random number generator has been implemented as
renpy.random. This random number generator cooperates with rollback,
always producing the same random numbers when a rollback occurs.

Added a set of UI functions, that allow the user to build up a user
interface themselves. These could be useful when implementing more
complex games, such as those that require the user to schedule a day
in advance. Also new is a new imagebutton, a button consisting of two
images.

Sticky postions have been implemented. Enabling this (using the
variable config.sticky_positions) cause the at clause corresponding to
a given character to be remembered, allowing the character to change
emotion without changing places on the screen (or requiring a second
at clause).

Rewrote the implementation of preferences, to clean up the code. Moved
it into its own file, preferences.rpy. Also, made it possible for a
user to add his own preferences into the system, although that isn't
really recommended.

The various imagemap functions now have a new parameter, unselected,
which gives an image to use when a hotspot is present but not
hovered. This lets us distinguish between between hotspots that are
present and exist, and hotspots that are totally absent. This could be
used to implement something like an image gallery that only displays
unlocked images.

Implemented config.keymap, which allows the changing of keys and mouse
buttons that trigger various Ren'Py events.

There's now a new look for loading and saving games, that allows 10
saves to be presented at once. I strongly recommend removing the 
library.file_page_length line at the start of your game scripts, if
it exists.

Fixed a bug in sound.init that lead to crashes in some cases.

Fixed a bug in ast.Node.predict that was causing an exception when
config.debug was turned on.

New in 4.2
----------

Ren'Py now ships with a common directory that is used to store the
library files, as well as the files needed by a minimal game. (Such as
a default font.) The idea here is to allow one to copy a game
directory from one version of Ren'Py to another, and have it just
work.

One can upgrade from 4.1 to 4.2 by deleting script.rpy, script.rpyc,
library.rpy, and library.rpyc, and then copying in the game
directory. 

We've also eliminated the default background images. To go back to the
images used with Ren'Py 4.1, add the following lines to your script,
and copy the images out of the 4.1 distribution, or your 4.1 based
game. 

[code]
init:
    $ style.mm_root_window.background = Image("mainmenu.jpg")
    $ style.gm_root_window.background = Image("gamemenu.jpg")
    $ style.window.background = Frame("frame.png", 125, 25)
[/code]

Fixed several bugs with the archiver. This version just might actually
work on Windows. 

Added a new variable, config.hard_rollback_limit, which limits the
number of steps the user can rollback the game, interactively. This
limit now defaults to 10 steps. (suggested by Grey) 

Added a second parameter to renpy.pause, that allows us to pause until
a particular offset in the background music is reached. (suggested by
Alessio)

Added keyboard mouse controls that can be used to move the mouse
around on the game and main menus. This allows us to manipulate the 
game and main menus without having to touch the mouse. This is mostly
for completeness. (suggested by Alessio)

Changed the way in which overlays work. We now have the variable
config.overlay_functions, which contains a list of functions, each of
which returns a list of displayables that will be added to the
screen. (sorta-kinda suggested by Alessio)

Removed renpy.set_overlay, since config.overlay_functions is a more 
flexible way of doing the same thing.

Now, defining the label main_menu allows you to totally replace the
main menu with something of your own devising. Changed the
documentation to reflect this, as well as the changes in startup that
happened in 4.1.

Added a program called "add_from", which adds from clauses to all bare
call statements found in the program. 

Replaced the menu_selected and menu_unselected styles with a single
menu_choice style which participates in the hover protocol. This may
change user code, if you change the menu colors. To fix this, replace
style.menu_selected.color with style.menu_choice.hover_color, and 
style.menu_unselected.color with style.menu_choice.idle_color.

Added the ability to play sound effects, by calling the renpy.play
function. Added a preference that allows the user to control if 
sound effects are played or not.

Added sound styles, which are used to define the sounds that are
played when buttons, imagemaps, and menu choices are hovered and
activated. (By default, no such sounds are played.)

Implemented that annoying thing where text is typed on the screen one
character at a time. Also added a preference that allows the user to
disable it. Used all the restraint I could muster to avoid defaulting
that preference to off.

Added the ability to fade out music when changing music
tracks. This is controlled by the config.fade_music variable.
(suggested by Alessio) 

Added parameterized images, and the ability to show text as image
using a command like:

[code]
show text "American Bishoujo Presents..."
[/code]

Added a Move function, which can be used in at to allow an image to be
moved on the screen. This is best used when the image is smaller than
the screen. (suggested by Alessio)

Changed the format of archive files, to make them somewhat harder to
reverse-engineer. This requires the user to regenerate the archive
files. To make this easier, we now ship a batch file (called
archive_images.bat) that automatically archives the images found in
the game directory.

Added a new function renpy.wait that is equivalent to the wait
statement, and made it and renpy.pause return True if they are
interrupted, or False if the run to their natural completions. This
now makes it possible to jump somewhere else when the user click,
rather than blindly going to the next label. For example:

[code]
# Actually, this runs before the library main menu.
label main_menu:
    scene black

    show text "American Bishoujo\nPresents" \
         at Move((0.5, 0.0), (0.5, 0.5), 3.0,
                 xanchor='center', yanchor='bottom')

    if renpy.pause(6):
        jump _library_main_menu

    show text "A PyTom Game" at Position(xpos=0.5, ypos=0.5,
                                         xanchor="center", yanchor="bottom")

    if renpy.with(fade) or renpy.pause(4):
        jump _library_main_menu

    $ renpy.transition(fade)
    jump _library_main_menu
[code]



Updated renpy-mode.el to add imenu support, so (X)Emacs users can use
the speedbar to jump around in a script. If you don't know what this
means, you probably don't care.

Improved the comments in the demo script, to make it a better
example. Added a syntax-highlighted version of the demo script to the
tutorial, to make it easier on peoples eyes.



New in 4.1
----------

Added the ability to customize the main menu by giving a list of
buttons on the main menu and the labels that they jump the user to.

Added the ability to center-click to hide any displayed text or menus.

Added the ability to have a color mouse that we can move around the
screen. 

Added a persistent object, which has fields that are persistent across
games. Made the preferences part of this object, so that they are
persisted across sessions. For simplicity's sake, made seen_ever part
of that persistent object.

Added a special character called "centered", which causes the text it
displays to be centered in the screen without any window. Added two
new styles (centered_window and centered_text), which are used for
this, and a new property, textalign, which controls the horizontal
alignment of text within the Text object itself.

Keywords are now special in all contexts. So you can no longer include
keywords in image names. Sorry.

Improved parse error messages. They now include the text of the
line and a caret indication the location in the line where the parse
error occurred.

Added a with clause to say statements and menus. This lets one display
dialogue, thoughts, or menus using a transition. In conjunction with
this, changed a bit the semantics of with statements, and with clauses
on show, hide, and scene statements. Rewrote the section on
transitions in the documentation to reflect the new reality.

Added the ability to translate the text of the game menu. Together
with the ability to change the main menu, this makes Ren'Py fully
localizable, except for error messages. Check out the Localization
section in the tutorial for more details.

Added confirmations for quitting and overwriting a save game. This
also includes quitting by trying to close the window.

Added a preferences screen, which lets users change the Ren'Py
preferences. Right now, this includes Windowed/Fullscreen, Music
Enabled/Disabled, CTRL Skips Unread/All messages, and Transitions
controls which transitions are performed.

Added a Pan function which can be used in an at clause. This allows us
to pan over a background image.
