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 arraigned 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.

