Bump version, update changelog.

the default for the projects directory, if it has not already been set 
by the user. It also will report an error when creating a project fails,
rather than producing a traceback.

.bzrignore

@@ -0,0 +1,60 @@
+build
+dist
+dists
+renpy.app
+**/*.rpyc
+**/*.rpyb
+**/*.rpymc
+jedit
+lint.txt
+renpy.code
+traceback.txt
+doc/common.css
+doc/images
+doc/index.html
+doc/monobook.css
+doc/monobook2.css
+doc/reference
+doc/shared.css
+doc/tutorials
+doc/www.renpy.org
+testing
+translations.rpy
+launchertrans.rpy
+jcc
+scite/scite.zip
+screenshot*
+.ropeproject
+release_cardgame.sh
+cardgame
+dse.split
+empty
+empty-linux-x86.tar.bz2
+empty-mac.zip
+empty.zip
+errors.txt
+icons
+iliad-icon.png
+iliad-work
+kuroi
+lsprofcalltree.py
+manifest.xml
+mediatest
+musicroom
+nobmtest
+renpy-iliad.sh
+renpy.kcg
+renpy.stats
+renpygame-1.2.zip
+speedtest
+styles.txt
+renpygame-demo/game/saves
+./lib
+Lucy Sprites.zip
+translate
+close_bugs.py
+.logplayer
+scite-6.10.zip
+scite-renpy-20090803.zip
+module/cython.sh
+old_demo

LICENSE.txt

@@ -0,0 +1,761 @@
+Ren'Py itself is covered by the terms of the following (MIT) license:
+
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation files
+(the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software,
+and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+Please see each individual source file for a list of copyright
+holders. The artwork in the demo is released by various copyright
+holders, under the same terms.
+
+
+The Ren'Py module, the Ren'Py windows binaries, and the various Ren'Py
+launchers may contain code taken from the following projects:
+
+    * Python (Python License)
+    * Pygame (LGPL)
+    * SDL (LGPL)
+    * SDL_image (LGPL)
+    * SDL_ttf (LGPL)
+    * SDL_mixer (LGPL)
+    * Freetype (LGPL)
+    * FFmpeg (LGPL)
+    * Fribidi (LGPL)
+    * jpeg (JPEG License)
+    * libpng (PNG license)
+    * zlib (Zlib License)
+    * bzip2 (Bzip2 License)
+    * pyobjc (MIT License)
+
+The Linux build may also include code from:
+
+    * directfb (LGPL)
+    * svgalib (LGPL)
+
+For the purpose of LGPL compliance, the source code to all LGPL
+software we depend on is either in the Ren'Py package (available from
+http://www.renpy.org/), or in the renpy-deps package
+(http://www.renpy.org/dl/lgpl/). We believe compliance can be achieved
+by including a copy of this license with every copy of Ren'Py you
+distribute, and referring to it in your project's README file.
+
+The default Ren'Py build distributes Ren'Py alongside jEdit, which is
+licensed under the GNU GPL. The source code to jEdit is distributed as
+part of the renpy-deps package (http://www.renpy.org/dl/lgpl/).
+
+
+GNU Lesser General Public License
+=================================
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+        51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations
+below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it
+becomes a de-facto standard.  To achieve this, non-free programs must
+be allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control
+compilation and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at least
+    three years, to give the same user the materials specified in
+    Subsection 6a, above, for a charge no more than the cost of
+    performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply, and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License
+may add an explicit geographical distribution limitation excluding those
+countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms
+of the ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.
+It is safest to attach them to the start of each source file to most
+effectively convey the exclusion of warranty; and each file should
+have at least the "copyright" line and a pointer to where the full
+notice is found.
+
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or
+your school, if any, to sign a "copyright disclaimer" for the library,
+if necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James
+  Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
+Python License
+==============
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using Python 2.3 software in source or binary form and its
+associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python 2.3
+alone or in any derivative version, provided, however, that PSF's
+License Agreement and PSF's notice of copyright, i.e., "Copyright (c)
+2001, 2002 Python Software Foundation; All Rights Reserved" are
+retained in Python 2.3 alone or in any derivative version prepared by
+Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python 2.3 or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python 2.3.
+
+4. PSF is making Python 2.3 available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 2.3 WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+2.3 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 2.3,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python 2.3, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+Jpeg License
+============
+
+In plain English:
+
+1. We don't promise that this software works.  (But if you find any bugs,
+   please let us know!)
+2. You can use this software for whatever you want.  You don't have to pay us.
+3. You may not pretend that you wrote this software.  If you use it in a
+   program, you must acknowledge somewhere in your documentation that
+   you've used the IJG code.
+
+In legalese:
+
+The authors make NO WARRANTY or representation, either express or implied,
+with respect to this software, its quality, accuracy, merchantability, or
+fitness for a particular purpose.  This software is provided "AS IS", and you,
+its user, assume the entire risk as to its quality and accuracy.
+
+This software is copyright (C) 1991-1998, Thomas G. Lane.
+All Rights Reserved except as specified below.
+
+Permission is hereby granted to use, copy, modify, and distribute this
+software (or portions thereof) for any purpose, without fee, subject to these
+conditions:
+(1) If any part of the source code for this software is distributed, then this
+README file must be included, with this copyright and no-warranty notice
+unaltered; and any additions, deletions, or changes to the original files
+must be clearly indicated in accompanying documentation.
+(2) If only executable code is distributed, then the accompanying
+documentation must state that "this software is based in part on the work of
+the Independent JPEG Group".
+(3) Permission for use of this software is granted only if the user accepts
+full responsibility for any undesirable consequences; the authors accept
+NO LIABILITY for damages of any kind.
+
+These conditions apply to any software derived from or based on the IJG code,
+not just to the unmodified library.  If you use our work, you ought to
+acknowledge us.
+
+Permission is NOT granted for the use of any IJG author's name or company name
+in advertising or publicity relating to this software or products derived from
+it.  This software may be referred to only as "the Independent JPEG Group's
+software".
+
+We specifically permit and encourage the use of this software as the basis of
+commercial products, provided that all warranty or liability claims are
+assumed by the product vendor.
+
+
+PNG License
+===========
+
+The PNG Reference Library is supplied "AS IS".  The Contributing Authors
+and Group 42, Inc. disclaim all warranties, expressed or implied,
+including, without limitation, the warranties of merchantability and of
+fitness for any purpose.  The Contributing Authors and Group 42, Inc.
+assume no liability for direct, indirect, incidental, special, exemplary,
+or consequential damages, which may result from the use of the PNG
+Reference Library, even if advised of the possibility of such damage.
+
+Permission is hereby granted to use, copy, modify, and distribute this
+source code, or portions hereof, for any purpose, without fee, subject
+to the following restrictions:
+
+1. The origin of this source code must not be misrepresented.
+
+2. Altered versions must be plainly marked as such and must not
+   be misrepresented as being the original source.
+
+3. This Copyright notice may not be removed or altered from any
+   source or altered source distribution.
+
+The Contributing Authors and Group 42, Inc. specifically permit, without
+fee, and encourage the use of this source code as a component to
+supporting the PNG file format in commercial products.  If you use this
+source code in a product, acknowledgment is not required but would be
+appreciated.
+
+Zlib License
+============
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+
+Bzip2 License
+=============
+
+This program, "bzip2", the associated library "libbzip2", and all
+documentation, are copyright (C) 1996-2005 Julian R Seward.  All
+rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. The origin of this software must not be misrepresented; you must 
+   not claim that you wrote the original software.  If you use this 
+   software in a product, an acknowledgment in the product 
+   documentation would be appreciated but is not required.
+
+3. Altered source versions must be plainly marked as such, and must
+   not be misrepresented as being the original software.
+
+4. The name of the author may not be used to endorse or promote 
+   products derived from this software without specific prior written 
+   permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

add.sh

@@ -0,0 +1,13 @@
+#!/bin/sh
+
+if [ "x$1" = "x" ]; then
+    echo need version
+    exit
+fi
+
+mkdir ~/ab/website/renpy/dl/$1
+cp dists/renpy-$1-* ~/ab/website/renpy/dl/$1
+cp CHANGELOG.txt ~/ab/website/renpy/dl/$1
+
+cd ~/ab/website
+./upload.sh

archive_images.bat

@@ -1,3 +0,0 @@
-cd game
-..\archiver.exe images *.png *.jpg
-pause

archiver.py

@@ -1,96 +0,0 @@
-#!/usr/bin/env python
-
-# The Ren'Py archiver. This builds a Ren'Py archive file, and the
-# associated index file. These files are really easy to reverse-engineer,
-# but are probably better than nothing.
-
-import sys
-import os
-import encodings.zlib_codec
-import random
-import glob
-
-from cPickle import loads, dumps, HIGHEST_PROTOCOL
-
-# The most we will go without inserting some padding. 10k.
-padding_every = 10240
-
-# The amount of padding we will add.
-padding_max = 32
-
-def randpadding():
-
-    plen = random.randint(1, padding_max)
-
-    rv = ""
-
-    for i in range(0, plen):
-        rv += chr(random.randint(1, 255))
-
-    return rv
-
-def main():
-    if len(sys.argv) < 3:
-        print "Usage: %s <file-prefix> <files ...>" % sys.argv[0]
-        return
-
-    prefix = sys.argv[1]
-
-    # Archive file.
-    archivef = file(prefix + ".rpa", "wb")
-
-    # Index file.
-    indexf = file(prefix + ".rpi", "wb")
-
-    index = { }
-
-    random.seed()
-
-    offset = 0
-
-    # Needed because windows sucks. It doesn't do globbing on the
-    # command line.
-    files = [ ]
-    for i in sys.argv[2:]:
-        files.extend(glob.glob(i))
-
-    for fn in files:
-        index[fn] = [ ]
-
-        print "Adding %s..." % fn
-
-        datafile = file(fn, "rb")
-
-        while True:
-
-            # Pad with junk.
-            padding = randpadding()
-            archivef.write(padding)
-            offset += len(padding)
-
-            # Pick a random block size.
-            block = random.randint(1, padding_every)
-
-            data = datafile.read(block)
-
-            if not data:
-                break
-
-            dlen = len(data)
-
-            archivef.write(data)
-
-            index[fn].append((offset, dlen))
-            offset += dlen
-                      
-        datafile.close()
-
-    archivef.close()
-
-    indexf.write(dumps(index, HIGHEST_PROTOCOL).encode("zlib"))
-    indexf.close()
-    
-    
-
-if __name__ == "__main__":
-    main()

build_exe.py

@@ -3,29 +3,78 @@
 from distutils.core import setup
 import py2exe
 import sys
+import zipfile
+import traceback
 
-if len(sys.argv) != 2:
-    print "Usage: build_exe.py <prefix>"
-    print ""
-    print "Builds <prefix>.exe."
-    print "Expects icons in <prefix>.ico."
+# The pythonpath on my system.
+sys.path.insert(0, 'c:\\msys\\1.0\\newbuild25\\install\\bin')
+sys.path.insert(0, 'c:\\msys\\1.0\\newbuild25\\install\\python')
 
-    sys.exit(-1)
+def main():
 
-def program(name):
-    return dict(script="run_game.py",
-                icon_resources=[ (0, name + ".ico"),
-                                 ],
-                dest_base=name)
+    sys.argv[1:] = [ 'py2exe', '--bundle', '2', '-a', '--dll-excludes', 'w9xpopen.exe', ]
+    # sys.argv[1:] = [ 'py2exe', '-a', '--dll-excludes', 'w9xpopen.exe', ]
 
-programs = [
-    program(sys.argv[1]),
-    ]
+    setup(name="RenPy",
+          windows=[ dict(script="renpy.py",
+                         dest_base="renpy",
+                         icon_resources=[ (1, "newicon.ico") ],
+                         ),
+                    ],
 
-sys.argv[1:] = [ 'py2exe' ]
+          console=[ dict(script="renpy.py", dest_base="console") ],
 
-setup(name="RenPy",
-      windows=programs,
-      console=[ "archiver.py", "add_from.py", "console.py" ],
-      zipfile='lib/renpy.zip',
-      )
+          zipfile='renpy.code',
+
+          options={ 'py2exe' : { 'excludes' : [ 'doctest',
+                                                'pygame.macosx',
+                                                'pygame.surfarray',
+                                                'pygame.mixer',
+                                                'pygame.mixer_music',
+                                                'pygame.font',
+                                                '_ssl',
+                                                '_hashlib',
+                                                'win32con',
+                                                'win32api',
+                                                'Numeric',
+                                                'locale',
+                                                'gettext',
+                                                'os2emxpath',
+                                                'macpath',
+                                                'posixpath',
+                                                ],
+                                 'optimize' : 2,
+                                 } },
+          )
+
+
+    zfold = zipfile.ZipFile("dist/renpy.code")
+    zfnew = zipfile.ZipFile("renpy.code", "w", zipfile.ZIP_STORED)
+
+    seen = { }
+
+    for fn in zfold.namelist():
+        if fn.startswith("renpy/"):
+            continue
+
+        if fn in seen:
+            continue
+
+        if fn == "SDL_mixer.dll":
+            continue
+        
+        seen[fn] = True
+
+        zfnew.writestr(fn, zfold.read(fn))
+
+    zfold.close()
+    zfnew.close()
+
+try:
+    main()
+except:
+    traceback.print_exc()
+
+print
+print "Press return to quit."
+raw_input()

build_pot.py

@@ -0,0 +1,84 @@
+1#!/usr/bin/env python
+
+import collections
+import glob
+import re
+import sys
+import time
+
+# A map from string to filename, line number where the string is found.
+strings = collections.defaultdict(list)
+
+def process(fn):
+
+    lineno = 0
+    
+    for data in file(fn, "r"):
+
+        lineno += 1
+
+        matches = [ ]
+        
+        matches += re.finditer(r'\bu\"(\\"|[^"])+\"', data)
+        matches += re.finditer(r"\bu\'(\\'|[^'])+\'", data)
+
+        for m in matches:
+            s = m.group(0)[2:-1]
+
+            if "\\u" in s:
+                continue
+
+            if len(s) == 1:
+                continue
+            
+            strings[s].append("%s:%d" % (fn, lineno))
+
+if __name__ == "__main__":
+
+    files = [ ]
+
+    files += glob.glob("launcher2/*.rpy")
+    files += glob.glob("common/*.rpy")
+    files += glob.glob("common/_layout/*.rpym")
+    files += glob.glob("common/_compat/*.rpym")
+        
+    for fn in files:
+        process(fn)
+
+
+    converse = [ ]
+        
+    for k, v in strings.iteritems():
+        v = " ".join(sorted(v))
+        converse.append((v, k))
+
+    converse.sort()
+
+    print """\
+# Ren'Py Visual Novel Engine
+# Copyright (C) 2009 PyTom <pytom@bishoujo.us>
+# This file is distributed under the same license as the Ren'Py package.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: mainline\\n"
+"Report-Msgid-Bugs-To: PyTom <pytom@bishoujo.us>\\n"
+"POT-Creation-Date: %s\\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"
+"Language-Team: LANGUAGE <LL@li.org>\\n"
+"MIME-Version: 1.0\\n"
+"Content-Type: text/plain; charset=UTF-8\\n"
+"Content-Transfer-Encoding: 8bit\\n"
+""" % time.strftime("%Y-%m-%d %H:%M%z")
+    
+    for v, k in converse:
+        print
+        print "#:", v
+        print "#, python-format"
+        print "msgid \"%s\"" % k
+        print "msgstr \"\""
+        
+        
+        

build_strings.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python
+
+import collections
+import glob
+import re
+import sys
+import time
+import os
+
+# A map from string to filename, line number where the string is found.
+strings = collections.defaultdict(list)
+
+def process(fn):
+
+    lineno = 0
+    
+    for data in file(fn, "r"):
+
+        lineno += 1
+
+        matches = [ ]
+        
+        matches += re.finditer(r'\bu\"(\\"|[^"])+\"', data)
+        matches += re.finditer(r"\bu\'(\\'|[^'])+\'", data)
+
+        for m in matches:
+            s = m.group(0)[2:-1]
+
+            if "\\u" in s:
+                continue
+
+            if len(s) == 1:
+                continue
+            
+            strings[s].append("%s:%d" % (fn, lineno))
+
+if __name__ == "__main__":
+
+    files = [ ]
+
+    files += glob.glob("launcher/*.rpy")
+    files += glob.glob("common/*.rpy")
+    files += glob.glob("common/*.rpym")
+    files += glob.glob("common/_layout/*.rpym")
+    files += glob.glob("common/_compat/*.rpym")
+
+    if "launcher/strings.rpy" in files:
+        files.remove("launcher/strings.rpy")
+    
+    for fn in files:
+        process(fn)
+
+    converse = [ ]
+        
+    for k, v in strings.iteritems():
+        v = " ".join(sorted(v))
+        converse.append((v, k))
+
+    converse.sort()
+
+    f = file("launcher/strings.rpy", "w")
+
+    files = set(i for i in os.listdir("launcher") if i.endswith(".rpy"))
+    
+    print >>f, """\
+init python:
+    LAUNCHER_RPYS = %r
+
+    TRANSLATION_STRINGS = [
+""" % files
+    
+    for v, k in converse:
+        # print
+        # print "#:", v
+        # print "#, python-format"
+
+        print >>f, "        u\"%s\"," % unicode(k)
+
+    print >>f, """\
+    ]
+"""

common/00atl.rpy

@@ -0,0 +1,35 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This file contains warpers that are used by ATL. They need to be defined
+# early, so Ren'Py knows about them when parsing other files.
+
+python early hide:
+
+    # pause is defined internally, but would look like:
+    #
+    # @renpy.atl_warper
+    # def pause(t):
+    #     if t >= 1.0:
+    #         return 1.0
+    #     else:
+    #         return 0.0
+    
+    @renpy.atl_warper
+    def linear(t):
+        return t
+
+    @renpy.atl_warper
+    def easeout(x):
+        import math
+        return 1.0 - math.cos(x * math.pi / 2.0)
+
+    @renpy.atl_warper
+    def easein(x):
+        import math
+        return math.cos((1.0 - x) * math.pi / 2.0)
+
+    @renpy.atl_warper
+    def ease(x):
+        import math
+        return .5 - math.cos(math.pi * x) / 2.0

common/00compat.rpy

@@ -0,0 +1,85 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init -1210 python:
+
+    # This is called when script_version is set, to immediately
+    # run code in response to a script_version change.        
+    def _set_script_version(version):
+
+        if version is None:
+            return
+
+        if version <= (5, 6, 0):
+            config.check_properties = False
+
+        if version <= (6, 5, 0):
+            layout.compat()
+
+        if version <= (6, 9, 1):
+            store.library = store.config
+
+        if version <= (6, 9, 3):
+
+            # Before 6.10, these were positions, rather than transforms.
+            store.left = Position(xalign=0.0)
+            store.center = Position(xalign=0.5)
+            store.truecenter = Position(xalign=0.5, yalign=0.5)
+            store.right = Position(xalign=1.0)
+            store.offscreenleft = Position(xpos=0.0, xanchor=1.0)
+            store.offscreenright = Position(xpos=1.0, xanchor=0.0)
+
+            
+            
+init 1210 python hide::
+
+    # This returns true if the script_version is <= the
+    # script_version supplied. Give it the last script version
+    # where an old version was used.
+    def compat(x, y, z):
+        return config.script_version and config.script_version <= (x, y, z)
+
+    # Compat for changes to with-callback.
+    if compat(5, 4, 5):
+        if config.with_callback:
+            def compat_with_function(trans, paired, old=config.with_callback):
+                old(trans)
+                return trans
+
+            config.with_callback = compat_with_function
+
+    if not config.sound:
+        config.has_sound = False
+        config.has_music = False
+        config.has_voice = False
+        
+    # Compat for SFont recoloring.
+    if compat(5, 1, 1):
+        config.recolor_sfonts = False
+
+    if compat(5, 5, 4):
+        config.implicit_with_none = False
+
+    # Compat for changes to button look.
+    if compat(5, 5, 4):            
+        style.button.setdefault(xpos=0.5, xanchor=0.5)
+        style.menu_button.clear()
+        style.menu_button_text.clear()
+
+    if compat(5, 6, 6):
+        config.reject_midi = False
+
+    if compat(6, 2, 0):
+        config.reject_backslash = False
+
+    if compat(6, 9, 0):
+        style.motion.clear()
+        
+    if "Fullscreen" in config.translations:
+        fs = _("Fullscreen")
+        config.translations.setdefault("Fullscreen 4:3", fs + " 4:3")
+        config.translations.setdefault("Fullscreen 16:9", fs + " 16:9")
+        config.translations.setdefault("Fullscreen 16:10", fs + " 16:10")
+            
+    for i in layout.compat_funcs:
+        i()

common/00definitions.rpy

@@ -0,0 +1,196 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This file contains a number of definitions of standard
+# locations and transitions. We've moved them into the common
+# directory so that it's easy for an updated version of all of these
+# definitions.
+
+init -1110:
+
+    transform reset:
+        alpha 1 rotate None zoom 1 xzoom 1 yzoom 1 align (0, 0) alignaround (0, 0) subpixel False size None crop None 
+   
+    # These are positions that can be used inside at clauses. We set
+    # them up here so that they can be used throughout the program.
+    transform left:
+        xpos 0.0 xanchor 0.0 ypos 1.0 yanchor 1.0
+
+    transform right:
+        xpos 1.0 xanchor 1.0 ypos 1.0 yanchor 1.0
+
+    transform center:
+        xpos 0.5 xanchor 0.5 ypos 1.0 yanchor 1.0
+
+    transform truecenter:
+        xpos 0.5 xanchor 0.5 ypos 0.5 yanchor 0.5
+        
+    # Offscreen positions for use with the move transition. Images at
+    # these positions are still shown (and consume
+    # resources)... remember to hide the image after the transition.    
+    transform offscreenleft:
+        xpos 0.0 xanchor 1.0 ypos 1.0 yanchor 1.0
+
+    transform offscreenright:
+        xpos 1.0 xanchor 0.0 ypos 1.0 yanchor 1.0
+
+    transform default:
+        reset
+        center
+
+    python:
+        config.default_transform = right
+        
+
+init -1110 python:
+
+    _define = define = object()
+        
+    # Positions ##############################################################
+
+
+    # Transitions ############################################################
+
+    # Simple transitions.
+    fade = Fade(.5, 0, .5) # Fade to black and back.
+    dissolve = Dissolve(0.5)
+    pixellate = Pixellate(1.0, 5)
+
+    # Various uses of CropMove.    
+    wiperight = CropMove(1.0, "wiperight")
+    wipeleft = CropMove(1.0, "wipeleft")
+    wipeup = CropMove(1.0, "wipeup")
+    wipedown = CropMove(1.0, "wipedown")
+
+    slideright = CropMove(1.0, "slideright")
+    slideleft = CropMove(1.0, "slideleft")
+    slideup = CropMove(1.0, "slideup")
+    slidedown = CropMove(1.0, "slidedown")
+
+    slideawayright = CropMove(1.0, "slideawayright")
+    slideawayleft = CropMove(1.0, "slideawayleft")
+    slideawayup = CropMove(1.0, "slideawayup")
+    slideawaydown = CropMove(1.0, "slideawaydown")
+
+    irisout = CropMove(1.0, "irisout")
+    irisin = CropMove(1.0, "irisin")
+
+    # Ease images around. These are basically cosine-warped moves.
+    def _ease_out_time_warp(x):
+        import math
+        return 1.0 - math.cos(x * math.pi / 2.0)
+
+    def _ease_in_time_warp(x):
+        import math
+        return math.cos((1.0 - x) * math.pi / 2.0)
+
+    def _ease_time_warp(x):
+        import math
+        return .5 - math.cos(math.pi * x) / 2.0
+
+    # This defines a family of move transitions.
+    def move_transitions(prefix, delay, time_warp=None, in_time_warp=None, out_time_warp=None, old=False, layers=[ 'master' ], **kwargs):
+        moves = {
+            "" : MoveTransition(
+                delay,
+                old=old,
+                layers=layers,
+                factory=MoveFactory(time_warp=time_warp, **kwargs)),
+
+            "inright" : MoveTransition(
+                delay,
+                old=old,
+                layers=layers,
+                factory=MoveFactory(time_warp=time_warp, **kwargs), 
+                enter_factory=MoveIn((1.0, None, 0.0, None), time_warp=in_time_warp, **kwargs)),
+
+            "inleft" : MoveTransition(
+                delay,
+                old=old,
+                layers=layers,
+                factory=MoveFactory(time_warp=time_warp, **kwargs), 
+                enter_factory=MoveIn((0.0, None, 1.0, None), time_warp=in_time_warp, **kwargs)),
+
+            "intop" : MoveTransition(
+                delay,
+                old=old,
+                layers=layers,
+                factory=MoveFactory(time_warp=time_warp, **kwargs), 
+                enter_factory=MoveIn((None, 0.0, None, 1.0), time_warp=in_time_warp, **kwargs)),
+
+            "inbottom" : MoveTransition(
+                delay,
+                old=old,
+                layers=layers,
+                factory=MoveFactory(time_warp=time_warp, **kwargs),
+                enter_factory=MoveIn((None, 1.0, None, 0.0), time_warp=in_time_warp, **kwargs)),
+
+            "outright" : MoveTransition(
+                delay,
+                old=old,
+                layers=layers,
+                factory=MoveFactory(time_warp=time_warp, **kwargs), 
+                leave_factory=MoveOut((1.0, None, 0.0, None), time_warp=out_time_warp, **kwargs)),
+
+            "outleft" : MoveTransition(
+                delay,
+                old=old,
+                layers=layers,
+                factory=MoveFactory(time_warp=time_warp, **kwargs), 
+                leave_factory=MoveOut((0.0, None, 1.0, None), time_warp=out_time_warp, **kwargs)),
+
+            "outtop" : MoveTransition(
+                delay,
+                old=old,
+                layers=layers,
+                factory=MoveFactory(time_warp=time_warp, **kwargs), 
+                leave_factory=MoveOut((None, 0.0, None, 1.0), time_warp=out_time_warp, **kwargs)),
+
+            "outbottom" : MoveTransition(
+                delay,
+                old=old,
+                layers=layers,
+                factory=MoveFactory(time_warp=time_warp, **kwargs), 
+                leave_factory=MoveOut((None, 1.0, None, 0.0), time_warp=time_warp, **kwargs)),
+            }
+
+        for k, v in moves.iteritems():
+            setattr(store, prefix + k, v)
+
+    define.move_transitions = move_transitions
+    del move_transitions
+
+    define.move_transitions("move", 0.5)
+    define.move_transitions("ease", 0.5, _ease_time_warp, _ease_in_time_warp, _ease_out_time_warp) 
+
+    # Zoom-based transitions.
+    zoomin = MoveTransition(0.5, enter_factory=ZoomInOut(0.01, 1.0))
+    zoomout = MoveTransition(0.5, leave_factory=ZoomInOut(1.0, 0.01))
+    zoominout = MoveTransition(0.5, enter_factory=ZoomInOut(0.01, 1.0), leave_factory=ZoomInOut(1.0, 0.01))
+    
+    # These shake the screen up and down for a quarter second.
+    # The delay needs to be an integer multiple of the period.
+    vpunch = Move((0, 10), (0, -10), .10, bounce=True, repeat=True, delay=.275)
+    hpunch = Move((15, 0), (-15, 0), .10, bounce=True, repeat=True, delay=.275)
+
+    # These use the ImageDissolve to do some nifty effects.
+    blinds = ImageDissolve(im.Tile("blindstile.png"), 1.0, 8)
+    squares = ImageDissolve(im.Tile("squarestile.png"), 1.0, 256)
+
+
+init -1110:
+    image black = Solid("#000")
+
+init 1110 python:
+    if not hasattr(store, 'narrator'):
+        narrator = Character(None, kind=adv, what_style='say_thought')
+
+    if not hasattr(store, 'name_only'):
+        name_only = adv
+
+    if not hasattr(store, 'centered'):
+        centered = Character(None, what_style="centered_text", window_style="centered_window")
+
+    # This is necessary to ensure that config.default_transform works.
+    if config.default_transform:
+        config.default_transform.show()

common/00layout.rpy

@@ -0,0 +1,353 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init -1105 python:
+
+    class Layout():
+        def __call__(self, func):
+            setattr(self, func.func_name, func)
+            return func
+
+    layout = _layout =  Layout()
+    del Layout
+
+    layout.compat_funcs = [ ]
+    layout.provided = set()
+    
+    # This takes care of actually displaying button menus.
+    def _display_button_menu(menuitems):
+        
+        narration = [ s for s, i in menuitems if i is None and s ]
+        menuitems = [ (s, i) for s, i in menuitems if i is not None or not s ]
+
+        if narration:
+            renpy.say(None, "\n".join(narration), interact=False)
+
+        return renpy.display_menu(menuitems)
+
+init -1105 python hide:
+
+    # Called to indicate that the given kind of layout has been
+    # provided.
+    @layout
+    def provides(kind):
+
+        if kind in layout.provided:
+            raise Exception("%s has already been provided by another layout function." % kind)
+        
+        layout.provided.add(kind)
+
+    # Called by registered themes to have the default versions of
+    # various kinds of layouts provided, if a more specific version
+    # has not been requested by the user.
+    @layout
+    def defaults():
+
+        # Do nothing, in compatibility mode.
+        if 'compat' in layout.provided:
+            return
+        
+        defaults = dict(
+            main_menu=layout.classic_main_menu,
+            load_save=layout.classic_load_save,
+            navigation=layout.classic_navigation,
+            yesno_prompt=layout.classic_yesno_prompt,
+            preferences=layout.classic_preferences,
+            joystick_preferences=layout.classic_joystick_preferences,
+            )
+
+        for k, v in defaults.iteritems():
+            if k not in layout.provided:
+                v()
+
+        if store._game_menu_screen is None:
+            if renpy.has_label("save_screen"):
+                store._game_menu_screen = "save_screen"
+            elif renpy.has_label("preferences_screen"):
+                store._game_menu_screen = "preferences_screen"
+            
+                
+    ##########################################################################
+    # These live on the layout object, and ease the construction of buttons,
+    # labels, and prompts. A sufficently aggressive layout might change
+    # these.
+
+    @layout
+    def button(label,
+               type=None,
+               selected=False,
+               enabled=True,
+               clicked=None,
+               hovered=None,
+               unhovered=None,
+               index=None,
+               **properties):
+        
+        """
+         label - The label of this button. Will be translated if necessary.
+         type - The type of this button. Used to generate the appropriate styles.
+         selected - Determines if this button should be selected.
+         enabled - Determines if this button should be enabled.
+         clicked - A function that is run when the button is clicked.
+         hovered - A function that is run when the button is hovered.
+         unhovered - A function that is run when the button is unhovered.
+         index - A style index. If None, label is used.
+         size_group - The size_group used by this button.
+         """
+
+        if not enabled:
+            clicked = None
+
+        if selected and enabled:
+            role = "selected_"
+        else:
+            role = ""
+
+        if type:
+            button_style = type + "_button"
+            text_style = type + "_button_text"
+        else:
+            button_style = 'button'
+            text_style = 'button_text'
+            
+        if index is None:
+            index = label
+        
+        button_style = getattr(style, button_style)[index]
+        text_style = getattr(style, text_style)[index]
+
+        rv = ui.button(style=button_style, role=role, clicked=clicked, hovered=hovered, unhovered=unhovered, **properties)
+        ui.text(_(label), style=text_style)
+
+        return rv
+
+    @layout
+    def label(label, type, suffix="label", index=None, **properties):
+
+        if index is None:
+            index = label
+
+        if type:
+            label_style = getattr(style, type + "_" + suffix)[index]
+            text_style = getattr(style, type + "_" + suffix + "_text")[index]
+        else:
+            label_style = style.label[index]
+            text_style = style.label_text[index]
+            
+        ui.window(style=label_style, **properties)
+        ui.text(_(label), style=text_style)
+
+    @layout
+    def prompt(label, type, index=None, **properties):
+        return layout.label(label, type, "prompt", index, **properties)
+
+    @layout
+    def list(entries, clicked=None, hovered=None, unhovered=None, selected=None, **properties):
+
+        ui.window(style=style.list, **properties)
+        ui.vbox(style=style.list_box)
+
+        size_group = str(id(entries))
+        
+        for i, (spacers, content) in enumerate(entries):
+            if clicked is not None:
+                new_clicked = renpy.curry(clicked)(i)
+            else:
+                new_clicked = None
+
+            if hovered is not None:
+                new_hovered = renpy.curry(hovered)(i)
+            else:
+                new_hovered = None
+                
+            if unhovered is not None:
+                new_unhovered = renpy.curry(unhovered)(i)
+            else:
+                new_unhovered = None
+
+            if selected == i:
+                role = "selected_"
+            else:
+                role = ""
+
+            ui.button(style=style.list_row[i%2],
+                      clicked=new_clicked,
+                      hovered=new_hovered, 
+                      unhovered=new_unhovered,
+                      role=role,
+                      size_group=size_group,
+                      )
+
+            ui.hbox(style=style.list_row_box)
+            
+            for j in range(0, spacers):
+                ui.window(style=style.list_spacer)
+                ui.null()
+
+            ui.text(content, style=style.list_text)
+
+            ui.close() # row
+            
+        ui.close() # vbox
+    
+    ##########################################################################
+    # Misc.
+                
+    @layout
+    def button_menu():
+
+        store.menu = _display_button_menu
+
+        style.menu.box_spacing = 2
+        style.menu_window.set_parent(style.default)
+        style.menu_window.xalign = 0.5
+        style.menu_window.yalign = 0.5
+        style.menu_choice.set_parent(style.button_text)
+        style.menu_choice.clear()
+        style.menu_choice_button.set_parent(style.button)
+        style.menu_choice_button.xminimum = int(config.screen_width * 0.75)
+        style.menu_choice_button.xmaximum = int(config.screen_width * 0.75)
+        
+    store._button_menu = button_menu
+
+    ###########################################################################
+    # Compat layout.
+                
+    @layout
+    def compat():
+        layout.provides('compat')
+        renpy.load_module("_compat/styles")
+        renpy.load_module("_compat/library")
+        renpy.load_module("_compat/mainmenu")
+        renpy.load_module("_compat/gamemenu")
+        renpy.load_module("_compat/preferences")
+        renpy.load_module("_compat/themes")
+
+    ###########################################################################
+    # Classic layout.
+
+    @layout
+    def classic_main_menu():
+        renpy.load_module("_layout/classic_main_menu")
+
+    @layout
+    def classic_navigation():
+        renpy.load_module('_layout/classic_navigation')
+
+    @layout
+    def classic_load_save():
+        renpy.load_module('_layout/classic_load_save')
+
+    @layout
+    def classic_yesno_prompt():
+        renpy.load_module('_layout/classic_yesno_prompt')
+
+    @layout
+    def classic_preferences(center=False):
+        renpy.load_module('_layout/classic_preferences')
+
+        if center:
+            style.prefs_button.xalign = 0.5
+            style.prefs_slider.xalign = 0.5
+            style.prefs_jump_button.xalign = 0.5
+
+    @layout
+    def classic_joystick_preferences():
+        renpy.load_module('_layout/classic_joystick_preferences')
+
+    @layout
+    def two_column_preferences():
+        renpy.load_module("_layout/two_column_preferences")
+        
+    @layout
+    def one_column_preferences():
+        renpy.load_module("_layout/one_column_preferences")
+
+    @layout
+    def grouped_main_menu(per_group=2, equal_size=True):
+        renpy.load_module("_layout/grouped_main_menu")
+        config.main_menu_per_group = per_group
+
+        if equal_size:
+            style.mm_button.size_group = "main_menu"
+
+            
+    @layout
+    def grouped_navigation(per_group=2, equal_size=True):
+        renpy.load_module("_layout/grouped_navigation")
+        config.navigation_per_group = per_group
+
+        if equal_size:
+            style.gm_nav_button.size_group = "navigation"
+
+    @layout
+    def scrolling_load_save():
+        renpy.load_module("_layout/scrolling_load_save")
+
+
+    @layout
+    def imagemap_main_menu(ground, selected, hotspots, idle=None, variant=None):
+        renpy.load_module("_layout/imagemap_main_menu")
+
+        config.main_menu_ground[variant] = ground
+        config.main_menu_selected[variant] = selected
+        config.main_menu_hotspots[variant] = hotspots
+        config.main_menu_idle[variant] = idle
+        
+    @layout
+    def imagemap_navigation(ground, idle, hover, selected_idle, selected_hover,
+                            hotspots):
+
+        renpy.load_module("_layout/imagemap_navigation")
+        
+        config.navigation_ground = ground
+        config.navigation_idle = idle
+        config.navigation_hover = hover
+        config.navigation_selected_idle = selected_idle
+        config.navigation_selected_hover = selected_hover
+        config.navigation_hotspots = hotspots
+
+    @layout
+    def imagemap_preferences(ground, idle, hover, selected_idle, selected_hover,
+                            hotspots):
+
+        renpy.load_module("_layout/imagemap_preferences")
+        
+        config.preferences_ground = ground
+        config.preferences_idle = idle
+        config.preferences_hover = hover
+        config.preferences_selected_idle = selected_idle
+        config.preferences_selected_hover = selected_hover
+        config.preferences_hotspots = hotspots
+
+    @layout
+    def imagemap_yesno_prompt(ground, idle, hover, hotspots, prompt_images={ }):
+
+        renpy.load_module("_layout/imagemap_yesno_prompt")
+        
+        config.yesno_prompt_ground = ground
+        config.yesno_prompt_idle = idle
+        config.yesno_prompt_hover = hover
+        config.yesno_prompt_hotspots = hotspots
+        config.yesno_prompt_message_images = prompt_images
+        
+    @layout
+    def imagemap_load_save(ground, idle, hover, selected_idle, selected_hover,
+                           hotspots, variant=None):
+
+        renpy.load_module("_layout/imagemap_load_save")
+        
+        config.load_save_ground[variant] = ground
+        config.load_save_idle[variant] = idle
+        config.load_save_hover[variant] = hover
+        config.load_save_selected_idle[variant] = selected_idle
+        config.load_save_selected_hover[variant] = selected_hover
+        config.load_save_hotspots[variant] = hotspots
+    
+
+    layout.ARE_YOU_SURE = u"Are you sure?"
+    layout.DELETE_SAVE = u"Are you sure you want to delete this save?"
+    layout.OVERWRITE_SAVE = u"Are you sure you want to overwrite your save?"
+    layout.LOADING = u"Loading will lose unsaved progress.\nAre you sure you want to do this?"
+    layout.QUIT = u"Are you sure you want to quit?"
+    layout.MAIN_MENU = u"Are you sure you want to return to the main menu?\nThis will lose unsaved progress."

common/00library.rpy

@@ -0,0 +1,832 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This file consists of renpy functions that aren't expected to be
+# touched by the user too much. We reserve the _ prefix for names
+# defined in the library.
+
+init -1180 python:
+
+    # These are settings that the user can tweak to control the
+    # look of the main menu and the load/save/escape screens.
+
+    # basics: The version of Ren'Py this script is intended for, or
+    # None if it's intended for the current version.
+    config.script_version = None
+    
+    # The minimum version of the module we work with. Don't change
+    # this unless you know what you're doing.
+    config.module_version = 6007001
+
+    # Should we warn the user if the module is missing or has a bad
+    # version?
+    config.module_warning = False
+
+    # basics: A map from a string that's displayed by the interface to
+    # a translated value of that string.
+    config.translations = { }
+
+    # Used internally to maintain compatiblity with old
+    # translations of strings.
+    config.old_names = { }
+
+    # basics: True if the skip indicator should be shown.
+    config.skip_indicator = True
+
+    # basics: The width of a thumbnail.
+    config.thumbnail_width = 66
+
+    # basics: The height of a thumbnail.
+    config.thumbnail_height = 50
+
+    # basics: If not None, the default value of the fullscreen
+    # preference when the game is first run.
+    config.default_fullscreen = None
+
+    # basics: If not None, the default value of the text_cps
+    # preference when the game is first run.
+    config.default_text_cps = None        
+
+    # Should we automatically define images?
+    config.automatic_images = None
+
+    # Prefixes to strip from automatic images.
+    config.automatic_images_strip = [ ]
+    
+    # A save to automatically load, if it exists.
+    config.auto_load = None
+
+    # Layers to clear when entering the menus.
+    config.menu_clear_layers = [ ]
+    
+    # This is updated to give the user an idea of where a save is
+    # taking place.
+    save_name = ''
+
+    # Should the window be shown during transitions?
+    _window_during_transitions = False
+
+    def _default_with_callback(trans, paired=None):
+        if (_window_during_transitions and not
+            renpy.context_nesting_level() and
+            not renpy.count_displayables_in_layer('transient')):
+
+            # narrator("", interact=False)
+            ui.window(style=style.say_window["empty"])
+            ui.null()
+            
+        return trans
+
+    config.with_callback = _default_with_callback
+
+
+    def _default_empty_window():
+        store.narrator("", interact=False)
+
+    config.empty_window = _default_empty_window
+        
+    style.skip_indicator = Style(style.default, heavy=True, help='The skip indicator.')
+    style.skip_indicator.xpos = 10
+    style.skip_indicator.ypos = 10
+
+    # This is used to jump to a label with a transition.
+    def _intra_jumps_core(label, transition):
+        renpy.transition(getattr(config, transition))
+        renpy.jump(label)
+
+    _intra_jumps = renpy.curry(_intra_jumps_core)
+
+
+    # The function that's used to translate strings in the game menu.
+    def _(s):
+        """
+        Translates s into another language or something.
+        """
+
+        if s in config.translations:
+            return config.translations[s]
+
+        if s in config.old_names and config.old_names[s] in config.translations:
+            return config.translations[config.old_names[s]]
+
+        return s
+
+    # Are the windows currently hidden?
+    _windows_hidden = False
+
+init -1180 python:
+
+    def toggle_skipping():
+
+        if not config.skipping:
+            config.skipping = "slow"
+        else:
+            config.skipping = None
+
+        if renpy.context()._menu:
+            renpy.jump("_noisy_return")
+        else:            
+            renpy.restart_interaction()
+
+    config.help = None
+            
+    def _help():
+        if not config.help:
+            return
+
+        if renpy.has_label(config.help):
+            renpy.call_in_new_context(config.help)
+            return
+
+        _preferences.fullscreen = False
+
+        try:
+            import webbrowser
+            webbrowser.open_new("file:///" + config.basedir + "/" + config.help)
+        except:
+            pass
+            
+    
+init -1180 python hide:
+
+    # Called to make a screenshot happen.
+    def screenshot():
+        import os.path
+        import os
+        import __main__
+        
+        pattern = os.environ.get("RENPY_SCREENSHOT_PATTERN", "screenshot%04d.png")
+
+        # Pick the directory to save into.
+        dest = config.renpy_base.rstrip("/")
+        
+        # Guess if we're an OSX App.
+        if dest.endswith("/Contents/Resources/autorun"):
+            # Go up 4 directories.
+            dest = os.path.dirname(dest)
+            dest = os.path.dirname(dest)
+            dest = os.path.dirname(dest)
+            dest = os.path.dirname(dest)
+
+        # Try to pick a filename.
+        i = 1
+        while True:
+            fn = dest + "/" + pattern % i
+            if not os.path.exists(fn):
+                break
+            i += 1
+
+        try:
+            renpy.screenshot(fn)
+        except:
+            import traceback
+            traceback.print_exc()
+        
+            
+    def dump_styles():
+        if config.developer:
+            renpy.style.write_text("styles.txt")
+
+    def invoke_game_menu():
+        if renpy.context()._menu:
+            renpy.jump("_noisy_return")
+        else:
+            renpy.call_in_new_context('_game_menu')
+
+    def keymap_toggle_skipping():
+        if renpy.context()._menu:
+            return
+
+        toggle_skipping()
+            
+    def fast_skip():
+        if config.fast_skipping or config.developer:
+            config.skipping = "fast"
+
+        if renpy.context()._menu:
+            renpy.jump("_noisy_return")
+
+    def reload_game():
+        if not config.developer:
+            return
+
+        renpy.call_in_new_context("_save_reload_game")
+
+    def launch_editor():
+        if not config.developer:
+            return
+
+        filename, line = renpy.get_filename_line()
+        renpy.launch_editor([ filename ], line)
+        
+    # The default keymap. We might also want to put some of this into
+    # the launcher.
+    km = renpy.Keymap(
+        rollback = renpy.rollback,
+        screenshot = screenshot,
+        toggle_fullscreen = renpy.toggle_fullscreen,
+        toggle_music = renpy.toggle_music,
+        toggle_skip = keymap_toggle_skipping,
+        fast_skip = fast_skip,
+        game_menu = invoke_game_menu,
+        hide_windows = renpy.curried_call_in_new_context("_hide_windows"),
+        launch_editor = launch_editor,
+        dump_styles = dump_styles,
+        reload_game = reload_game,
+        developer = renpy.curried_call_in_new_context("_developer"),
+        quit = renpy.quit_event,
+        iconify = renpy.iconify,
+        help = _help,
+        )
+
+    config.underlay = [ km ]
+
+    def skip_indicator():
+
+        ### skip_indicator default
+        # (text) The style and placement of the skip indicator.            
+
+        if config.skip_indicator is True:
+
+            if config.skipping == "slow" and config.skip_indicator:
+                ui.text(_(u"Skip Mode"), style='skip_indicator')
+
+            if config.skipping == "fast" and config.skip_indicator:
+                ui.text(_(u"Fast Skip Mode"), style='skip_indicator')
+
+            return
+
+        if not config.skip_indicator:
+            return
+
+        if not config.skipping:
+            return
+
+        ui.add(renpy.easy.displayable(config.skip_indicator))
+
+    config.overlay_functions.append(skip_indicator)
+
+
+    def hyperlink_styler(target):
+        return style.hyperlink_text
+
+    def hyperlink_function(target):
+        if target.startswith("http:"):
+            try:
+                import webbrowser
+                webbrowser.open(target)
+            except:
+                pass
+        else:
+            renpy.call_in_new_context(target)
+
+    config.hyperlink_styler = hyperlink_styler
+    config.hyperlink_callback = hyperlink_function
+        
+
+    config.extend_interjection = "{fast}"
+    
+init -1180 python:
+    def extend(what, interact=True):
+        who = _last_say_who
+
+        if who is not None:
+            who = eval(who)
+
+        if who is None:
+            who = narrator 
+            
+        if isinstance(who, basestring):
+            who = unknown.copy(who)
+
+        # This ensures extend works even with NVL mode.
+        who.do_extend()
+            
+        what = _last_say_what + config.extend_interjection + what
+            
+        renpy.exports.say(who, what, interact=interact)
+        store._last_say_what = what
+        
+    extend.record_say = False
+
+
+label _hide_windows:
+
+    if renpy.context()._menu:
+        return
+    
+    if _windows_hidden:
+        return
+
+    python:
+        _windows_hidden = True
+        ui.saybehavior(dismiss=['dismiss', 'hide_windows'])
+        ui.interact(suppress_overlay=True, suppress_window=True)
+        _windows_hidden = False
+
+    return
+
+    
+# This code here handles check for the correct version of the Ren'Py module.
+                         
+label _save_reload_game:
+    python hide:
+        renpy.take_screenshot((config.thumbnail_width, config.thumbnail_height))
+                
+        ui.add(Solid((0, 0, 0, 255)))
+        ui.text("Saving game...",
+                size=32, xalign=0.5, yalign=0.5, color=(255, 255, 255, 255))
+
+        renpy.pause(0)
+        renpy.save("reload", "reload save game")
+
+        renpy.music.stop()
+        
+        persistent._reload_save = "reload"
+        
+        ui.add(Solid((0, 0, 0, 255)))
+        ui.text("Reloading script...",
+                size=32, xalign=0.5, yalign=0.5, color=(255, 255, 255, 255))
+
+        renpy.pause(0)
+        
+        renpy.utter_restart()
+
+label _load_reload_game:
+
+    if not persistent._reload_save:
+        return
+
+    python hide:
+        save = persistent._reload_save
+        persistent._reload_save = 0
+
+        ui.add(Solid((0, 0, 0, 255)))
+        ui.text("Reloading game...",
+                size=32, xalign=0.5, yalign=0.5, color=(255, 255, 255, 255))
+
+        ui.pausebehavior(0)
+        ui.interact(suppress_underlay=True, suppress_overlay=True)
+        
+        renpy.load(save)
+
+    return
+
+init -1001:
+    image text = renpy.ParameterizedText(style="centered_text")
+
+    # Lock the library object.
+    $ config.locked = True
+
+
+# Implement config.default_fullscreen and config.default_text_cps.
+init 1180 python:
+
+    if not persistent._set_preferences:
+        persistent._set_preferences = True
+        
+        if config.default_fullscreen is not None:
+            _preferences.fullscreen = config.default_fullscreen
+
+        if config.default_text_cps is not None:
+            _preferences.text_cps = config.default_text_cps
+
+    if config.developer:
+
+        def _inspector(l):
+
+            ui.add("#000")
+            ui.window(xmargin=20, ymargin=20, style='default')
+            ui.vbox()
+
+            ui.text("Style Inspector")
+            ui.text("")
+
+
+            if not l:
+                ui.text("Nothing to inspect.")
+            
+            for depth, width, height, d in l:
+
+                s = d.style
+
+                while s:
+                    if s.name:
+                        break
+                    
+                    if s.parent:
+                        s = style.get(s.parent)
+                    else:
+                        break
+                        
+                name = s.name[0] + "".join([ "[%r]" % i for i in s.name[1:] ]) 
+
+                ui.text("  " * depth + u" \u2022 " + d.__class__.__name__ + " : " + name + " (%dx%d)" % (width, height))
+
+            ui.text("")
+            ui.text("(click to continue)")
+                
+            ui.close()
+            ui.saybehavior()
+            ui.interact(suppress_overlay=True, suppress_underlay=True)
+            
+            return
+
+        config.inspector = _inspector
+        
+##############################################################################
+# Code that originated in 00gamemenu.rpy
+init -1180 python:
+
+    ######################################################################
+    # First up, we define a bunch of configuration variable, which the
+    # user can change.
+
+    # menus: Music to play when entering the game menu.
+    config.game_menu_music = None
+
+    # menus: Sound played when entering the library without clicking a
+    # button.
+    config.enter_sound = None
+
+    # menus: Sound played when leaving the library without clicking a
+    # button.
+    config.exit_sound = None
+
+    # menus: Transition that occurs when entering the game menu.
+    config.enter_transition = None
+
+    # menus: Transition that occurs when leaving the game menu.
+    config.exit_transition = None
+
+    # menus: Transition that's used when going from one screen to another.
+    config.intra_transition = None
+
+    # menus: Transition that's used when going from the main to the game
+    # menu.
+    config.main_game_transition = None
+
+    # menus: Transition that's used when going from the game to the main
+    # menu.
+    config.game_main_transition = None
+
+    # menus: Transition that's used at the end of the game, when returning
+    # to the main menu.
+    config.end_game_transition = None
+
+    # menus: Transition that's used at the end of the splash screen, when
+    # it is shown.
+    config.end_splash_transition = None
+
+    # Transition that's used after the game is loaded.
+    config.after_load_transition = None
+    
+    # basics: True if autosave should be used.
+    config.has_autosave = True
+
+    # basics: True if quicksave has been enabled.
+    config.has_quicksave = False
+
+    # A list of layers to clear when entering the main and game menus.
+    config.clear_layers = [ ]
+
+    # The _window_subtitle used inside menus.
+    config.menu_window_subtitle = ''
+    
+    # The screen that we go to when entering the game menu.
+    _game_menu_screen = None
+    
+    style.error_root = Style(style.default)
+    style.error_title = Style(style.default)
+    style.error_body = Style(style.default)
+
+    def _show_exception(title, message):
+
+        ui.window(style='error_root')
+        ui.vbox()
+
+        ui.text(title, style='error_title')
+        ui.text("")
+        ui.text(message, style='error_body')
+        ui.text("")
+        ui.text(_(u"Please click to continue."), style='error_body')
+
+        ui.close()
+
+        ui.saybehavior()
+
+        ui.interact()
+
+        
+# Run at the end of init, to set up autosaving based on the user's
+# choices.
+init 1180 python:
+
+    if config.has_autosave:
+        config.autosave_slots = 10
+    else:
+        config.autosave_frequency = None
+            
+label _enter_menu:
+    python hide:
+        renpy.movie_stop(only_fullscreen=True)
+        renpy.take_screenshot((config.thumbnail_width, config.thumbnail_height))
+
+        for i in config.menu_clear_layers:
+            renpy.scene(layer=i)
+        
+        renpy.context()._menu = True
+        
+        # This may be changed, if we are already in the main menu.
+        renpy.context().main_menu = False
+        renpy.context_dynamic("main_menu")
+        renpy.context_dynamic("_window_subtitle")
+        renpy.context_dynamic("_window")
+        
+        store.main_menu = False
+        store._window_subtitle = config.menu_window_subtitle
+        store._window = False
+        
+        store.mouse_visible = True
+        store.suppress_overlay = True
+        ui.clear()
+
+        for i in config.clear_layers:
+            renpy.scene(layer=i)
+        
+    return
+    
+# Factored this all into one place, to make our lives a bit easier.
+label _enter_game_menu:
+    call _enter_menu from _call__enter_menu_2
+
+    $ renpy.transition(config.enter_transition)
+
+    if renpy.has_label("enter_game_menu"):
+        call expression "enter_game_menu" from _call_enter_game_menu_1
+
+    if config.game_menu_music:
+        $ renpy.music.play(config.game_menu_music, if_changed=True)
+
+    return
+
+# Entry points from the game into menu-space.
+label _game_menu(_game_menu_screen=_game_menu_screen):
+    if not _game_menu_screen:
+        return
+
+    $ renpy.play(config.enter_sound)
+    
+    call _enter_game_menu from _call__enter_game_menu_0
+
+    if renpy.has_label("game_menu"):
+        jump expression "game_menu"
+        
+    jump expression _game_menu_screen
+
+label _game_menu_save:
+    call _enter_game_menu from _call__enter_game_menu_1
+
+    if renpy.has_label("_save_screen"):
+        jump expression "_save_screen"
+    else:
+        jump expression "save_screen"
+
+label _game_menu_load:
+    call _enter_game_menu from _call__enter_game_menu_2
+
+    if renpy.has_label("_load_screen"):
+        jump expression "_load_screen"
+    else:
+        jump expression "load_screen"
+
+label _game_menu_preferences:
+    call _enter_game_menu from _call__enter_game_menu_3
+
+    if renpy.has_label("_prefs_screen"):
+        jump expression "_prefs_screen"
+    else:
+        jump expression "preferences_screen"
+
+label _quit:
+    $ renpy.quit()
+
+label _return_skipping:
+    $ config.skipping = "slow"
+    jump _return
+    
+# Make some noise, then return.
+label _noisy_return:
+    $ renpy.play(config.exit_sound)
+
+# Return to the game.
+label _return:
+
+    if renpy.context().main_menu:
+        $ renpy.transition(config.game_main_transition)
+        jump _main_menu_screen
+
+    $ renpy.transition(config.exit_transition)
+
+    return
+
+label _confirm_quit:
+    call _enter_menu from _call__enter_menu_3
+
+    if renpy.has_label("confirm_quit"):
+        jump expression "confirm_quit"
+    elif renpy.has_label("_compat_confirm_quit"):
+        jump expression "_compat_confirm_quit"
+    else:
+        jump expression "_quit_prompt"
+
+
+##############################################################################
+# Code that originated in 00mainmenu.rpy
+
+init -1180 python hide:
+
+    # menus: Music to play at the main menu.
+    config.main_menu_music = None
+
+    # advanced: Callbacks to run at start.
+    config.start_callbacks = [ ]
+
+
+# This fixes up the context, if necessary, then calls the real
+# after_load.
+label _after_load:
+    $ renpy.context()._menu = False
+
+    if config.after_load_transition:
+        $ renpy.transition(config.after_load_transition, force=True)
+    
+    if renpy.has_label("after_load"):
+        jump expression "after_load"
+    else:
+        return
+
+    
+# This is the true starting point of the program. Sssh... Don't
+# tell anyone.
+label _start:
+
+    python hide:
+        renpy.context()._menu = False
+        
+        for i in config.start_callbacks:
+            i()
+    
+    call _load_reload_game from _call__load_reload_game_1
+
+    if not _restart and config.auto_load and renpy.can_load(config.auto_load):
+        $ renpy.load(config.auto_load)
+    
+    scene black
+
+    if not _restart:
+        $ ui.pausebehavior(0)
+        $ ui.interact(suppress_underlay=True, suppress_overlay=True)
+
+    $ renpy.block_rollback()
+
+    $ _old_game_menu_screen = _game_menu_screen
+    $ _game_menu_screen = None
+    
+    if renpy.has_label("splashscreen") and not _restart:
+        call expression "splashscreen" from _call_splashscreen_1
+
+    $ _game_menu_screen = _old_game_menu_screen
+    $ del _old_game_menu_screen
+        
+    $ renpy.block_rollback()
+
+    if config.main_menu_music:
+        $ renpy.music.play(config.main_menu_music, if_changed=True)
+    else:
+        $ renpy.music.stop()
+        
+    # Clean out any residual scene from the splashscreen.
+    scene black
+
+
+    # This has to be python, to deal with a case where _restart may
+    # change across a shift-reload.
+    python:
+        if _restart is None:
+            renpy.transition(config.end_splash_transition)
+        else:
+            renpy.transition(_restart[0])
+            renpy.jump(_restart[1])
+        
+label _invoke_main_menu:
+
+    # Again, this has to be python.
+    python:
+        if _restart:
+            renpy.call_in_new_context(_restart[2])
+        else:
+            renpy.call_in_new_context("_main_menu")
+        
+        
+    # If the main menu returns, then start the game.
+    jump start
+
+# At this point, we've been switched into a new context. So we
+# initialize it.
+label _main_menu(_main_menu_screen="_main_menu_screen"):
+
+    call _enter_menu from _call__enter_menu_1
+
+    python:
+        renpy.dynamic("_load_prompt")
+        _load_prompt = False
+
+        renpy.context().main_menu = True
+        store.main_menu = True
+
+    jump expression _main_menu_screen
+        
+# This is called to show the main menu to the user.
+label _main_menu_screen:    
+
+    # Let the user completely override the main menu. (But please note
+    # it still lives in the menu context, rather than the game context.)
+    if renpy.has_label("main_menu"):
+        jump expression "main_menu"
+
+    # New name.
+    if renpy.has_label("main_menu_screen"):
+        jump expression "main_menu_screen"
+
+    # Compatibility name.
+    if renpy.has_label("_library_main_menu"):
+        jump expression "_library_main_menu"
+        
+    return
+
+init 1180 python hide:
+    
+    def create_automatic_images():
+    
+        seps = config.automatic_images
+
+        if seps is True:
+            seps = [ ' ', '/', '_' ]
+            
+        for dir, fn in renpy.loader.listdirfiles():
+
+            if fn.startswith("_"):
+                continue
+
+            # Only .png and .jpg
+            if not fn.lower().endswith(".png") and not fn.lower().endswith(".jpg"):
+                continue
+
+            # Strip the extension, replace slashes.
+            shortfn = fn[:-4].replace("\\", "/")
+            
+            # Determine the name.
+            name = ( shortfn, )
+            for sep in seps:
+                name = tuple(j for i in name for j in i.split(sep))
+
+            # Strip name components.
+            while name:
+                for i in config.automatic_images_strip:
+                    if name[0] == i:
+                        name = name[1:]
+                        break
+                else:
+                    break
+                
+            # Only names of 2 components or more.
+            if len(name) < 2:
+                continue
+            
+            # Reject if it already exists.
+            if name in renpy.exports.images:
+                continue
+
+            renpy.image(name, fn)
+
+    if config.automatic_images:
+        create_automatic_images()
+
+
+# Load the developer screen, if necessary.
+init 1180 python hide:
+
+    if config.developer:
+        renpy.load_module("_developer")
+
+# Entry point for the developer screen. The rest of it is loaded from
+# _developer.rpym
+label _developer:
+
+    if not config.developer:
+        return
+
+    call _enter_menu from _call__enter_menu_4
+
+    jump expression "_developer_screen"

common/00menus.rpy

@@ -0,0 +1,44 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# Common stuff that's used by the various Ren'Py menus. This includes
+# the default definitions of config.main_menu and config.game_menu, as
+# well as the default definitions of the various preferences (and the objects
+# holding those preferences)
+
+init -1150 python:
+
+    config.main_menu = [
+        (u"Start Game", "start", "True"),
+        (u"Load Game", _intra_jumps("load_screen", "main_game_transition"), "True"),
+        (u"Preferences", _intra_jumps("preferences_screen", "main_game_transition"), "True"),
+        (u"Help", _help, "True", "config.help"),
+        (u"Quit", ui.jumps("_quit"), "True"),
+        ]
+
+    config.game_menu = [
+        ( None, u"Return", ui.jumps("_return"), 'True'),
+        ( "preferences", u"Preferences", _intra_jumps("preferences_screen", "intra_transition"), 'True' ),
+        ( "save", u"Save Game", _intra_jumps("save_screen", "intra_transition"), 'not main_menu' ),
+        ( "load", u"Load Game", _intra_jumps("load_screen", "intra_transition"), 'True'),
+        ( None, u"Main Menu", ui.callsinnewcontext("_main_menu_prompt"), 'not main_menu' ),
+        ( "help", u"Help", _help, "True", "config.help"),
+        ( None, u"Quit", ui.callsinnewcontext("_quit_prompt"), 'True' ),
+        ]
+
+label _quit_prompt:
+    $ renpy.loadsave.force_autosave()
+
+    if layout.yesno_prompt(None, layout.QUIT):
+        jump _quit
+    else:
+        return
+
+label _main_menu_prompt:
+    if layout.yesno_prompt(None, layout.MAIN_MENU):
+        $ renpy.full_restart(transition=config.game_main_transition)
+    else:
+        return
+
+    
+ 

common/00mixers.rpy

@@ -0,0 +1,63 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This file contains code that sets up the various mixers, based on how
+# the user sets config.has_music, .has_sound, and .has_voice.
+
+init -1130 python hide:
+    
+    # Set to true in the very unlikely event you want to manually init
+    # the sound system.
+    config.force_sound = False
+
+    # basics: True if the game will have music.
+    config.has_music = True
+
+    # basics: True if the game will have sound effects.
+    config.has_sound = True
+
+    # Register 8 channels by default, for compatiblity with older version
+    # of Ren'Py.
+    for i in xrange(0, 8):
+        renpy.music.register_channel(i)
+
+    renpy.music.register_channel("movie", "music", False, stop_on_mute=False)
+        
+    # Set up default names for some of the channels.
+    renpy.music.alias_channel(0, "sound")
+    renpy.music.alias_channel(7, "music")
+    renpy.music.alias_channel(2, "voice")
+    
+init 1130:
+
+    python hide:
+
+        if not config.has_music and not config.has_sound:
+            mixers = None
+            
+        elif not config.has_music and config.has_sound:
+            mixers = [ 'sfx' ] * 8
+
+        elif config.has_music and not config.has_sound:
+            mixers = [ 'music' ] * 8
+
+        else:
+            mixers = [ 'sfx' ] * 3 + [ 'music' ] * 5
+
+        if config.has_voice:
+            if not mixers:
+                mixers = [ 'voice' ] * 8
+            else:
+                mixers[2] = 'voice'
+
+        if not mixers:
+            config.sound = config.force_sound
+
+        else:
+            for i, m in enumerate(mixers):
+                renpy.sound.set_mixer(i, m, default=True)
+                if m == 'music':
+                    renpy.music.set_music(i, True, default=True)
+                else:
+                    renpy.music.set_music(i, False, default=True)
+        

common/00nvl_mode.rpy

@@ -0,0 +1,339 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This is an implementation of NVL-mode, which can be used to show
+# dialogue in a fullscreen way, like NVL-style games. Multiple lines
+# of dialogue are shown on the screen at once, whenever a line of
+# dialogue is said by a NVLCharacter. Calling the nvl_clear function
+# clears the screen, ensuring that the the next line will appear at
+# the top of the screen.
+#
+# You can also have menus appear on the screen, by running:
+#
+# init:
+#     $ menu = nvl_menu
+#
+# It's also possible to make the narrator a NVLCharacter, using code like:
+#
+# init:
+#     $ narrator = NVLCharacter(None)
+        
+##############################################################################
+# The implementation of NVL mode lives below this line.
+
+init -1100 python:
+
+    # Styles that are used by nvl mode.
+    style.create('nvl_window', 'default', 'the window containing nvl-mode dialogue')
+    style.create('nvl_vbox', 'vbox', 'the vbox containing each box of nvl-mode dialogue')
+    style.create('nvl_label', 'say_label', 'an nvl-mode character\'s name')
+    style.create('nvl_dialogue', 'say_dialogue', 'nvl-mode character dialogue')
+    style.create('nvl_entry', 'default', 'a window containing each line of nvl-mode dialogue')
+
+    style.create('nvl_menu_window', 'default', 'a window containing an nvl-mode menu')
+    style.create('nvl_menu_choice', 'default', 'an nvl-mode menu choice')
+    style.create('nvl_menu_choice_chosen', 'nvl_menu_choice', 'an nvl-mode menu choice that has been chosen')
+    style.create('nvl_menu_choice_button', 'default', 'an nvl-mode choice button')
+    style.create('nvl_menu_choice_chosen_button', 'nvl_menu_choice_button', 'an nvl-mode choice button that\'s been chosen.')
+
+    # Set up nvl mode styles.
+    style.nvl_label.minwidth = 150
+    style.nvl_label.text_align = 1.0
+
+    style.nvl_window.background = "#0008"
+    style.nvl_window.yfill = True
+    style.nvl_window.xfill = True
+    style.nvl_window.xpadding = 20
+    style.nvl_window.ypadding = 30
+
+    style.nvl_vbox.box_spacing = 10
+
+    style.nvl_menu_choice.idle_color = "#0ff"
+    style.nvl_menu_choice.hover_color = "#ff0"
+    style.nvl_menu_choice_button.left_margin = 160
+    style.nvl_menu_choice_button.right_margin = 20
+    style.nvl_menu_choice_button.xfill = True
+    style.nvl_menu_choice_button.hover_background = "#F0F2"
+
+    # nvlmode: The CTC indicator to use when at the end of an NVL page.
+    config.nvl_page_ctc = None
+
+    # nvlmode: The position of the CTC indicator used at the end of an NVL page.
+    config.nvl_page_ctc_position = "nestled"
+
+    # Should we used paged rollback?
+    config.nvl_paged_rollback = False
+
+    # A hook that delta wanted, that is called instead of renpy.show_display_say
+    config.nvl_show_display_say = renpy.show_display_say
+    
+    # A list of arguments that have been passed to nvl_record_show.
+    nvl_list = None
+
+    # If set, then all of the nvl-specific style get indexed with this.
+    nvl_variant = None
+
+    # Returns the appropriate variant style.
+    def __s(s):
+        if nvl_variant:
+            return s[nvl_variant]
+        else:
+            return s
+    
+    def nvl_show_core():
+        
+        if renpy.in_rollback():
+            nvl_window = __s(style.nvl_window)['rollback']
+            nvl_vbox = __s(style.nvl_vbox)['rollback']
+        else:
+            nvl_window = __s(style.nvl_window)
+            nvl_vbox = __s(style.nvl_vbox)
+        
+        ui.window(style=nvl_window)
+        ui.vbox(style=nvl_vbox)
+
+        rv = None
+
+        for i in nvl_list:
+            if not i:
+                continue
+
+            who, what, kw = i                
+            rv = config.nvl_show_display_say(who, what, variant=nvl_variant, **kw)
+
+        ui.close()
+
+        renpy.shown_window()
+        
+        return rv
+
+    def nvl_window():
+        nvl_show_core()
+    
+    def nvl_show(with_):
+        nvl_show_core()
+        renpy.with_statement(with_)
+
+    def nvl_hide(with_):
+        nvl_show_core()
+        renpy.with_statement(None)
+        renpy.with_statement(with_)
+
+    def nvl_erase():
+        if nvl_list:
+            nvl_list.pop()
+
+    # Check to see if one of the next statements is nvl clear.
+    def nvl_clear_next():
+
+        # The number of statements forward to look.
+        count = 10
+
+        scry = renpy.scry()
+        scry = scry.next()
+
+        while count and scry:
+
+            count -= 1
+            if scry.nvl_clear:
+                return True
+
+            if scry.interacts:
+                return False
+
+            scry = scry.next()
+        
+            
+    class NVLCharacter(ADVCharacter):
+
+        def __init__(self, 
+                     who=renpy.character.NotSet,
+                     kind=None,
+                     **properties):
+            
+            if kind is None:
+                kind = store.nvl
+            
+            if "clear" in properties:
+                self.clear = properties.pop("clear")
+            else:
+                self.clear = kind.clear
+
+            ADVCharacter.__init__(
+                self, 
+                who,
+                kind=kind,
+                **properties)
+
+        def do_add(self, who, what):
+            if store.nvl_list is None:
+                store.nvl_list = [ ]
+                
+            kwargs = self.show_args.copy()
+            kwargs["what_args"] = self.what_args
+            kwargs["who_args"] = self.who_args
+            kwargs["window_args"] = self.window_args
+            
+            store.nvl_list.append((who, what, kwargs))
+
+        def do_display(self, who, what, **display_args):
+
+            page = self.clear or nvl_clear_next()
+
+            if config.nvl_page_ctc and page:
+                display_args["ctc"] = config.nvl_page_ctc
+                display_args["ctc_position"] = config.nvl_page_ctc_position
+
+            if config.nvl_paged_rollback:
+                if page:
+                    checkpoint = True
+                else:
+                    if renpy.in_rollback():
+                        return
+                    checkpoint = False
+            else:
+                checkpoint = True
+                
+            renpy.display_say(nvl_show_core,
+                              checkpoint=checkpoint,
+                              **display_args)
+            
+        def do_done(self, who, what):
+            
+            if self.clear:
+                nvl_clear()
+
+        def do_extend(self):
+            store.nvl_list = store.nvl_list[:-1]
+                
+    # The default NVLCharacter.
+    nvl = NVLCharacter(
+        show_say_vbox_properties={ 'box_layout' : 'horizontal' },
+        who_style='nvl_label',
+        what_style='nvl_dialogue',
+        window_style='nvl_entry',
+        type='nvl',
+        clear=False,
+        kind=adv)
+                
+    def nvl_clear():
+        store.nvl_list = [ ]
+
+    # Run clear at the start of the game.
+    config.start_callbacks.append(nvl_clear)
+
+    def nvl_menu(items):
+
+        if nvl_list is None:
+            store.nvl_list = [ ]
+
+        ui.layer("transient")
+        ui.clear()
+        ui.close()
+            
+        ui.window(style=__s(style.nvl_window))
+        ui.vbox(style=__s(style.nvl_vbox))
+
+        for i in nvl_list:
+            if not i:
+                continue
+
+            who, what, kw = i            
+            rv = renpy.show_display_say(who, what, **kw)
+
+        renpy.display_menu(items, interact=False,
+                           window_style=__s(style.nvl_menu_window),
+                           choice_style=__s(style.nvl_menu_choice),
+                           choice_chosen_style=__s(style.nvl_menu_choice_chosen),
+                           choice_button_style=__s(style.nvl_menu_choice_button),
+                           choice_chosen_button_style=__s(style.nvl_menu_choice_chosen_button),
+                           )
+
+        ui.close()
+
+        roll_forward = renpy.roll_forward_info()
+
+        rv = ui.interact(roll_forward=roll_forward)
+        renpy.checkpoint(rv)
+
+        return rv
+
+    NVLSpeaker = NVLCharacter
+    
+    config.nvl_adv_transition = None
+    config.adv_nvl_transition = None
+
+init 1140 python:
+
+    if config.nvl_adv_transition or config.adv_nvl_transition:
+
+        def _nvl_adv_callback(event, interact, type, **kwargs):
+        
+            if event != "begin" or not interact or renpy.get_transition():
+                return 
+            
+            old_type = renpy.last_interact_type()
+
+            if old_type == "say" and type == "nvl":
+                # We have an extra line in the nvl_list as we do this. So
+                # take it out for the duration of the nvl_show.
+                old_nvl_list = store.nvl_list
+                store.nvl_list = old_nvl_list[:-1]
+                nvl_show(config.adv_nvl_transition)
+                store.nvl_list = old_nvl_list
+            elif old_type == "nvl" and type == "say":
+                nvl_hide(config.nvl_adv_transition)
+
+        config.all_character_callbacks.insert(0, _nvl_adv_callback)
+
+    
+python early hide:
+
+    def parse_nvl_show_hide(l):
+        rv = l.simple_expression()
+        if rv is None:
+            renpy.error('expected simple expression')
+
+        if not l.eol():
+            renpy.error('expected end of line')
+
+        return rv
+            
+    def lint_nvl_show_hide(trans):
+        _try_eval(trans, 'transition')
+
+    def execute_nvl_show(trans):
+        nvl_show(eval(trans))
+
+    def execute_nvl_hide(trans):
+        nvl_hide(eval(trans))
+
+    renpy.statements.register("nvl show",
+                              parse=parse_nvl_show_hide,
+                              execute=execute_nvl_show,
+                              lint=lint_nvl_show_hide)
+
+    renpy.statements.register("nvl hide",
+                              parse=parse_nvl_show_hide,
+                              execute=execute_nvl_hide,
+                              lint=lint_nvl_show_hide)
+
+    def parse_nvl_clear(l):
+        if not l.eol():
+            renpy.error('expected end of line')
+
+        return None
+
+    def execute_nvl_clear(parse):
+        nvl_clear()
+
+    def scry_nvl_clear(parse, scry):
+        scry.nvl_clear = True
+        
+    renpy.statements.register('nvl clear',
+                              parse=parse_nvl_clear,
+                              execute=execute_nvl_clear,
+                              scry=scry_nvl_clear)
+
+
+    

common/00splines.rpy

@@ -0,0 +1,135 @@
+# This file contains the spline motion code contributed by Aenakume, at
+# http://lemmasoft.renai.us/forums/viewtopic.php?f=8&t=3977
+
+init -1080 python:
+    class _SplineInterpolator(object):
+   
+        ANCHORS = {
+            'top'    : 0.0,
+            'center' : 0.5,
+            'bottom' : 1.0,
+            'left'   : 0.0,
+            'right'  : 1.0,
+            }
+   
+        def __init__(self, points, anchors=(0.5, 0.5)):
+     
+            assert len(points) >= 2, "Need at least a start and end point."
+     
+            def setup_coordinate_(c):
+                if len(c) == 2:
+                    c += anchors
+                return [ self.ANCHORS.get(i, i) for i in c ]
+     
+            self.points = []
+            
+            for p in points:
+                length = len(p)
+                
+                if isinstance(p[-1], float):
+                    length = len(p) - 1
+                    point = [ p[-1] ]
+                else:
+                    length = len(p)
+                    point = [ -1 ]
+       
+                self.points.append(point + [ setup_coordinate_(p[i]) for i in range(length) ])
+     
+            # Make sure start and end times are set, if not already set
+            if self.points[0][0] == -1:
+                self.points[0][0] = 0.0
+            if self.points[-1][0] == -1:
+                self.points[-1][0] = 1.0
+     
+            # Now we gotta calculate the step times that need calculating
+            for start in range(1, len(self.points) - 1):
+                if self.points[start][0] != -1:
+                    continue
+       
+                end = start + 1
+       
+                while end < (len(self.points) - 1) and self.points[end][0] == -1:
+                    end += 1
+       
+                step = (self.points[end][0] - self.points[start - 1][0]) / float(end - start + 1)
+       
+                for i in range(start, end):
+                    self.points[i][0] = self.points[i - 1][0] + step
+     
+            # And finally, sort the list of points by increasing time
+            self.points.sort(key=lambda a : a[0])
+     
+            self.initialized = None
+   
+        def init_values(self, sizes):
+            def to_abs_(value, size):
+                if type(value) ==  float:
+                    return value * size
+                else:
+                    return value
+     
+            def coord_(c):
+
+                if len(c) == 2:
+                    c = c + (0, 0)
+
+                return ( to_abs_(c[0], sizes[0]) - to_abs_(c[2], sizes[2]),
+                         to_abs_(c[1], sizes[1]) - to_abs_(c[3], sizes[3]) )
+
+            for p in self.points:
+                for i in range(1, len(p)):
+                    p[i] = coord_(p[i])
+     
+            self.initialized = sizes
+  
+        def __call__(self, t, sizes):
+            # Initialize if necessary
+            if not self.initialized == sizes:
+                self.init_values(sizes)
+     
+            # Now we must determine which segment we are in
+            for segment in range(len(self.points)):
+                if self.points[segment][0] > t:
+                    break
+     
+            # If this is the zeroth segment, just start at the start point
+            if segment == 0:
+                result = self.points[0][1]
+            # If this is past the last segment, just leave it at the end point
+            elif segment == len(self.points) - 1 and t > self.points[-1][0]:
+                result = self.points[-1][1]
+            else:
+                # Scale t
+                t = (t - self.points[segment - 1][0]) / (self.points[segment][0] - self.points[segment - 1][0])
+       
+            # Get start and end points
+            start = self.points[segment - 1][1]
+            end   = self.points[segment][1]
+       
+            # Now what kind of interpolation is it?
+            if len(self.points[segment]) == 2:   # Straight line
+                t_p = 1.0 - t
+
+                result = [ t_p * start[i] + t * end[i] for i in 0,1 ]
+
+            elif len(self.points[segment]) == 3: # Quadratic Bezier
+                t_pp = (1.0 - t)**2
+                t_p = 2 * t * (1.0 - t)
+                t2 = t**2
+         
+                result = [ t_pp * start[i] + t_p * self.points[segment][2][i] + t2 * end[i] for i in 0,1 ]
+
+            elif len(self.points[segment]) == 4: # Cubic Bezier
+                t_ppp = (1.0 - t)**3
+                t_pp = 3 * t * (1.0 - t)**2
+                t_p = 3 * t**2 * (1.0 - t)
+                t3 = t**3
+         
+                result = [ t_ppp * start[i] + t_pp * self.points[segment][2][i] + t_p * self.points[segment][3][i] + t3 * end[i] for i in 0,1 ]
+
+            return ( absolute(result[0]), absolute(result[1]), 0, 0 )
+
+    def SplineMotion(points, time, child=None, anchors=(0.5, 0.5), repeat=False, bounce=False, anim_timebase=False, style='default', time_warp=None, **properties):
+        return Motion(_SplineInterpolator(points, anchors), time, child, repeat=repeat, bounce=bounce, anim_timebase=anim_timebase, style=style, time_warp=time_warp, add_sizes=True, **properties)
+
+  

common/00statements.rpy

@@ -0,0 +1,455 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This file contains code that creates a few new statements. We'll
+# also describe here the API for defining your own statements.
+#
+# Statements can be defined by calling renpy.statements.register. This
+# function takes a string giving the keywords at the start of the
+# statement, and then up to 4 functions defining the behavior of the
+# statement: parse, execute, predict, and lint
+#
+# The parse function takes a lexer object as an argument, and is
+# expected to return some parser data. The lexer has the following
+# methods.
+#
+# l.eol() - True if we are at the end of the line.
+# l.match(re) - Matches an arbitrary regexp string.
+# l.keyword(s) - Matches s.
+# l.name() - Matches any non-keyword name. Note that this only
+# counts built-in keywords.
+# l.word() - Matches any word, period.
+# l.string() - Matches a renpy string.
+# l.integer() - Matches an integer, returns a string containing the
+# integer.
+# l.float() - Matches a floating point number.
+# l.simple_expression() - Matches a simple python expression, returns
+# it as a string.
+# l.rest() - Skips whitespace, then returns the rest of the line.
+# l.checkpoint() - Returns an opaque object representing the current
+# point in the parse.
+# l.revert(o) - Given the object returned by l.checkpoint(), returns
+# there.
+#
+# The parse function is expected to return an object, which is passed
+# to the other functions. Parse should call renpy.error with the error
+# message to report an error.
+#
+# The execute function is passed the object returned from parse, and
+# is expected to execute the statement.
+#
+# The predict function is passed the object returned from parse, and
+# is expected to return a list of images that are used by the
+# statement.
+#
+# The lint function is called at lint time, after the init code is
+# run. It should check the statement for errors, and report them by
+# calling renpy.error with the appropriate error message.
+#
+# The scry function is called with a scry object. It may mutate that
+# object, but it is then expected to return it. See 00nvlmode.rpy for
+# details.
+# 
+# The next function is expected to return a string giving the label of
+# the next statement to execute, or None to indicate that next
+# statement in the block should be executed. The next function is
+# called during predict, scry, and execute, and should always return
+# the same value. (Or scrying may be incorrect.)
+
+
+python early hide:
+
+    # Music play - The example of a full statement.
+    
+    def parse_play_music(l):
+
+        file = l.simple_expression()
+        if not file:
+            renpy.error("play requires a file")
+
+        fadeout = "None"
+        fadein = "0"
+        channel = None
+        loop = None
+        if_changed = False
+        
+        while True:
+
+            if l.eol():
+                break
+
+            if l.keyword('fadeout'):
+                fadeout = l.simple_expression()
+                if fadeout is None: 
+                    renpy.error('expected simple expression')
+
+                continue
+            
+            if l.keyword('fadein'):
+                fadein = l.simple_expression()
+                if fadein is None: 
+                    renpy.error('expected simple expression')
+
+                continue
+            
+            if l.keyword('channel'):
+                channel = l.simple_expression()
+                if channel is None:
+                    renpy.error('expected simple expression')
+
+                continue
+
+            if l.keyword('loop'):
+                loop = True
+                continue
+                
+            if l.keyword('noloop'):
+                loop = False
+                continue
+
+            if l.keyword('if_changed'):
+                if_changed = True
+                continue
+            
+            renpy.error('could not parse statement.')
+
+        return dict(file=file,
+                    fadeout=fadeout,
+                    fadein=fadein,
+                    channel=channel,
+                    loop=loop,
+                    if_changed=if_changed)
+
+    def execute_play_music(p):
+
+        if p["channel"] is not None:
+            channel = eval(p["channel"])
+        else:
+            channel = 7
+        
+        renpy.music.play(eval(p["file"]),
+                         fadeout=eval(p["fadeout"]),
+                         fadein=eval(p["fadein"]),
+                         channel=channel,
+                         loop=p.get("loop", None),
+                         if_changed=p.get("if_changed", False))
+
+    def predict_play_music(p):
+        return [ ]
+
+    def lint_play_music(p):
+
+        file = _try_eval(p["file"], 'filename')
+        if p["channel"] is not None:
+            _try_eval(p["channel"], 'channel')
+
+        if not isinstance(file, list):
+            file = [ file ]
+
+        for fn in file:
+            if isinstance(fn, basestring) and not renpy.loadable(fn):
+                renpy.error("%r is not loadable" % fn)
+    
+    renpy.statements.register('play music',
+                              parse=parse_play_music,
+                              execute=execute_play_music,
+                              predict=predict_play_music,
+                              lint=lint_play_music)
+
+    # From here on, we'll steal bits of other statements when defining other
+    # statements.
+
+    def parse_queue_music(l):
+
+        file = l.simple_expression()
+        if not file:
+            renpy.error("queue requires a file")
+
+        channel = None
+        loop = None
+        
+        while not l.eol():
+        
+            if l.keyword('channel'):
+                channel = l.simple_expression()
+                if channel is None:
+                    renpy.error('expected simple expression')
+
+            if l.keyword('loop'):
+                loop = True
+                continue
+                
+            if l.keyword('noloop'):
+                loop = False
+                continue
+
+            renpy.error('expected end of line')
+
+        return dict(file=file, channel=channel, loop=loop)
+
+    def execute_queue_music(p):
+        if p["channel"] is not None:
+            channel = eval(p["channel"])
+        else:
+            channel = 7
+        
+        renpy.music.queue(
+            eval(p["file"]),
+            channel=channel,
+            loop=p.get("loop", None))
+
+
+    renpy.statements.register('queue music',
+                              parse=parse_queue_music,
+                              execute=execute_queue_music,
+                              lint=lint_play_music)
+
+    def parse_stop_music(l):
+        fadeout = "None"
+
+        if l.keyword("fadeout"):
+            fadeout = l.simple_expression()
+
+        channel = None
+            
+        if l.keyword('channel'):
+            channel = l.simple_expression()
+            if channel is None:
+                renpy.error('expected simple expression')
+
+        if not l.eol():
+            renpy.error('expected end of line')
+
+        if fadeout is None: 
+            renpy.error('expected simple expression')
+
+        return dict(fadeout=fadeout, channel=channel)
+
+    def execute_stop_music(p):
+        if p["channel"] is not None:
+            channel = eval(p["channel"])
+        else:
+            channel = 7
+        
+        renpy.music.stop(fadeout=eval(p["fadeout"]), channel=channel)
+
+    renpy.statements.register('stop music',
+                              parse=parse_stop_music,
+                              execute=execute_stop_music)
+
+
+    # Sound statements. They share alot with the equivalent music
+    # statements.
+
+    def execute_play_sound(p):
+        
+        if p["channel"] is not None:
+            channel = eval(p["channel"])
+        else:
+            channel = 0
+
+        fadeout = eval(p["fadeout"]) or 0
+            
+        renpy.sound.play(eval(p["file"]),
+                         fadeout=fadeout,
+                         fadein=eval(p["fadein"]),
+                         channel=channel)
+                       
+    renpy.statements.register('play sound',
+                              parse=parse_play_music,
+                              execute=execute_play_sound,
+                              lint=lint_play_music)
+
+    def execute_queue_sound(p):
+        if p["channel"] is not None:
+            channel = eval(p["channel"])
+        else:
+            channel = 0
+
+        renpy.sound.queue(eval(p["file"]), channel=channel)
+
+
+    renpy.statements.register('queue sound',
+                              parse=parse_queue_music,
+                              execute=execute_queue_sound,
+                              lint=lint_play_music)
+
+    def execute_stop_sound(p):
+        if p["channel"] is not None:
+            channel = eval(p["channel"])
+        else:
+            channel = 0
+
+        fadeout = eval(p["fadeout"]) or 0
+
+        renpy.sound.stop(fadeout=fadeout, channel=channel)
+
+    renpy.statements.register('stop sound',
+                              parse=parse_stop_music,
+                              execute=execute_stop_sound)
+
+
+    # Generic play/queue/stop statements. These take a channel name as
+    # the second thing.
+
+    def parse_play_generic(l, parse_play_music=parse_play_music):
+        channel = l.name()
+
+        if channel is None:
+            renpy.error('play requires a channel')
+
+        rv = parse_play_music(l)
+        if rv["channel"] is None:
+            rv["channel"] = repr(channel)
+
+        return rv
+
+    def parse_queue_generic(l, parse_queue_music=parse_queue_music):
+        channel = l.name()
+
+        if channel is None:
+            renpy.error('queue requires a channel')
+
+        rv = parse_queue_music(l)
+        if rv["channel"] is None:
+            rv["channel"] = repr(channel)
+
+        return rv
+
+    def parse_stop_generic(l, parse_stop_music=parse_stop_music):
+        channel = l.name()
+
+        if channel is None:
+            renpy.error('stop requires a channel')
+
+        rv = parse_stop_music(l)
+        if rv["channel"] is None:
+            rv["channel"] = repr(channel)
+
+        return rv
+
+    def lint_play_generic(p, lint_play_music=lint_play_music):
+        channel = eval(p["channel"])
+        
+        if not renpy.music.channel_defined(channel):
+            renpy.error("channel %r is not defined" % channel)
+
+        lint_play_music(p)
+
+    def lint_stop_generic(p):
+        channel = eval(p["channel"])
+        
+        if not renpy.music.channel_defined(channel):
+            renpy.error("channel %r is not defined" % channel)
+
+    renpy.statements.register('play',
+                              parse=parse_play_generic,
+                              execute=execute_play_music,
+                              predict=predict_play_music,
+                              lint=lint_play_generic)
+    
+    renpy.statements.register('queue',
+                              parse=parse_queue_generic,
+                              execute=execute_queue_music,
+                              lint=lint_play_generic)
+            
+    renpy.statements.register('stop',
+                              parse=parse_stop_generic,
+                              execute=execute_stop_music,
+                              lint=lint_stop_generic)
+
+
+    ##########################################################################
+    # "window show" and "window hide" statements.
+
+    def parse_window(l):
+        p = l.simple_expression()
+        if not l.eol():
+            renpy.error('expected end of line')
+
+        return p
+            
+    def lint_window(p):
+        if p is not None:
+            _try_eval(p, 'window transition')
+
+    def execute_window_show(p):
+        if store._window:
+            return
+
+        if p is not None:
+            trans = eval(p)
+        else:
+            trans = config.window_show_transition
+            
+        renpy.with_statement(None)
+        store._window = True
+        renpy.with_statement(trans)
+        
+    def execute_window_hide(p):
+        if not _window:
+            return
+        
+        if p is not None:
+            trans = eval(p)
+        else:
+            trans = config.window_hide_transition
+
+        renpy.with_statement(None)
+        store._window = False
+        renpy.with_statement(trans)
+
+    renpy.statements.register('window show',
+                              parse=parse_window,
+                              execute=execute_window_show,
+                              lint=lint_window)
+
+    renpy.statements.register('window hide',
+                              parse=parse_window,
+                              execute=execute_window_hide,
+                              lint=lint_window)
+
+    ##########################################################################
+    # Pause statement.
+    
+    def parse_pause(l):
+
+        delay = l.simple_expression()
+
+        if not l.eol():
+            renpy.error("expected end of line.")
+
+        return { "delay" : delay }
+
+    def lint_pause(p):
+
+        if p["delay"]:
+            _try_eval(p["delay"], 'pause statement')
+            
+    def execute_pause(p):
+
+        if p["delay"]:
+            delay = eval(p["delay"])
+            renpy.with_statement(Pause(delay))
+        else:
+            renpy.pause()
+
+
+    renpy.statements.register('pause',
+                              parse=parse_pause,
+                              lint=lint_pause,
+                              execute=execute_pause)
+            
+    
+                              
+init -1200 python:
+
+    config.window_show_transition = None
+    config.window_hide_transition = None
+    
+    def _try_eval(e, what):
+        try:
+            return eval(e)
+        except:
+            renpy.error('unable to evaluate %s %r' % (what, e))
+    

common/00style.rpy

@@ -0,0 +1,311 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This file is responsible for creating and defining the default styles
+# used by the system.
+
+# This file should be considered part of the Ren'Py library, and not
+# something that needs to be modified by the user. Instead, just update
+# the appropriate style property in an init: block in your script.
+#
+# For example, to change the default window backgrounds to a
+# transparent dark red, add:
+#
+# init:
+#     $ style.window.background = "#8008"
+#
+# to your script. No need to mess around here, it will just make your
+# life harder when a new version of Ren'Py is released.
+
+init -1200 python hide:
+
+    # Style Declarations #################################################
+
+    style.default = Style(None, help='root of style hierarchy')
+
+    style.hbox = Style(style.default, help='horizontal boxes')
+    style.vbox = Style(style.default, help='vertical boxes')
+
+    style.window = Style(style.default, help='windows created with ui.window')
+
+    style.image_placement = Style(style.default, help='default placement of images on the screen')
+    style.image = Style(style.default, help="default style of images")
+
+    style.motion = Style(style.default, help="default style of motions and zooms.")
+    style.animation = Style(style.default, help="default style of animations.")
+
+    style.say_label = Style(style.default, help='the name of the character speaking dialogue.')
+    style.say_dialogue = Style(style.default, help='used for dialogue text')
+    style.say_thought = Style(style.default, help='used by the default narrator')
+    style.say_window = Style(style.window, help='windows containing dialogue and thoughts')
+    style.say_who_window = Style(style.window, help='window containing the label in two-window-say mode')
+    style.say_two_window_vbox = Style(style.vbox, help='vbox containing the two windows in two-window-say mode')
+    style.say_vbox = Style(style.vbox, help='contains the label (if present) and the body of dialogue')
+
+    style.menu = Style(style.default, help='the vbox containing an in-game menu')
+    style.menu_caption = Style(style.default, help='in-game menu caption text')
+    style.menu_choice = Style(style.default, help='text of an in-game menu choice')
+    style.menu_choice_button = Style(style.default, help='buttons containing in-game menu choices')
+    style.menu_choice_chosen = Style(style.menu_choice, help='text of an in-game menu choice that has been chosen')
+    style.menu_choice_chosen_button = Style(style.menu_choice_button, help='buttons containing chosen in-game menu choices')
+    style.menu_window = Style(style.window, help='a window containing a menu')
+
+    style.input_text = Style(style.default, help='text of an input box')
+    style.input_prompt = Style(style.default, help='prompt of an input box')
+    style.input_window = Style(style.window, help='window of an input box')
+
+    style.centered_window = Style(style.default, help='window containing centered text')
+    style.centered_text = Style(style.default, help='centered text')
+
+    style.imagemap = Style(style.image_placement, help='default style of imagemaps')
+    style.imagemap_button = Style(style.default, help='default style of buttons inside imagemaps')
+
+    style.image_button = Style(style.default, help='default style of image buttons')
+    style.image_button_image = Style(style.default, help='default style of images inside image buttons')
+
+    style.hyperlink = Style(style.default, help=None) # ignored
+    style.hyperlink_text = Style(style.default, help='hyperlinked text')
+
+    style.viewport = Style(style.default, help='default style of viewports')
+    style.transform = Style(style.motion, help='default style of transforms')
+    
+    style.list = Style(style.default)
+    style.list_box = Style(style.vbox)
+    style.list_row = Style(style.default)
+    style.list_row_box = Style(style.hbox)
+    style.list_spacer = Style(style.default)    
+    style.list_text = Style(style.default)
+
+# The base styles that can be customized by themes.
+
+    style.frame = Style(style.default, help='base style for frames.')
+    style.menu_frame = Style(style.frame, help='base style for frames used in the game and main menus.')
+    
+    style.button = Style(style.default, help='base style for buttons.')
+    style.button_text = Style(style.default, help='base style for button text')
+
+    style.small_button = Style(style.button, help="base style for small buttons")
+    style.small_button_text = Style(style.button_text, help="base style for small button text")
+    style.radio_button = Style(style.button, help="base style for radio buttons")
+    style.radio_button_text = Style(style.button_text, help="base style for radio button text")
+    style.check_button = Style(style.button, help="base style for check buttons")
+    style.check_button_text = Style(style.button_text, help="base style for check button text")
+
+    style.large_button = Style(style.default, help="base style for large buttons")
+    style.large_button_text = Style(style.default, help="base style for large button text")
+
+    style.label = Style(style.default, help="base style for windows surrounding labels")
+    style.label_text = Style(style.default, help="base style for label text")
+
+    style.prompt = Style(style.default, help="base style for windows surrounding prompts")
+    style.prompt_text = Style(style.default, help="base style for prompt text")
+    
+    style.bar = Style(style.default, help='base style for horizontal bars')
+    style.vbar = Style(style.default, help='base style for vertical bars')
+
+    style.slider = Style(style.default, help='base style for horizontal sliders')
+    style.vslider = Style(style.default, help='base style for vertical sliders')
+
+    style.scrollbar = Style(style.default, help='base style for horizontal scrollbars')
+    style.vscrollbar = Style(style.default, help='base style for vertical scollbars')
+
+    style.mm_root = Style(style.default, help="main menu root window")
+    style.gm_root = Style(style.default, help="game menu root window")
+
+    
+init -1090 python:
+    
+    # Colors #############################################################
+
+    # The Default Style ###################################################
+
+    # Text properties.
+    style.default.font = "DejaVuSans.ttf"
+    style.default.language = "western"
+    style.default.antialias = True
+    style.default.size = 22
+    style.default.color = (255, 255, 255, 255)
+    style.default.black_color = (0, 0, 0, 255)
+    style.default.bold = False
+    style.default.italic = False
+    style.default.underline = False
+    style.default.strikethrough = False
+    style.default.drop_shadow = None
+    style.default.drop_shadow_color = (0, 0, 0, 255)
+    style.default.outlines = [ ]
+    style.default.minwidth = 0
+    style.default.text_align = 0
+    style.default.justify = False
+    style.default.text_y_fudge = 0
+    style.default.first_indent = 0
+    style.default.rest_indent = 0
+    style.default.line_spacing = 0
+    style.default.layout = "greedy"
+    style.default.subtitle_width = 0.9
+    style.default.slow_cps = None
+    style.default.slow_cps_multiplier = 1.0
+    style.default.slow_abortable = False
+    
+    # Window properties.
+    style.default.background = None
+    style.default.xpadding = 0
+    style.default.ypadding = 0
+    style.default.xmargin = 0
+    style.default.ymargin = 0
+    style.default.xfill = False
+    style.default.yfill = False
+    style.default.xminimum = 0 # Includes margins and padding.
+    style.default.yminimum = 0 # Includes margins and padding.
+
+    # Placement properties.
+    style.default.xpos = None # 0
+    style.default.ypos = None # 0
+    style.default.xanchor = None # 0
+    style.default.yanchor = None # 0
+    style.default.xmaximum = None
+    style.default.ymaximum = None
+    style.default.xoffset = 0
+    style.default.yoffset = 0
+    style.default.subpixel = False
+    
+    # Sound properties.
+    style.default.sound = None
+
+    # Box properties.
+    style.default.spacing = 0
+    style.default.first_spacing = None
+    style.default.box_layout = None
+
+    # Focus properties.
+    style.default.focus_mask = None
+    style.default.focus_rect = None
+
+    # Bar properties.
+    style.default.fore_bar = Null()
+    style.default.aft_bar = Null()
+    style.default.thumb = None
+    style.default.thumb_shadow = None
+    style.default.left_gutter = 0
+    style.default.right_gutter = 0
+    style.default.thumb_offset = 0
+    style.default.unscrollable = None
+    
+    # Misc.
+    style.default.activate_sound = None
+    style.default.clipping = False
+
+    # Boxes.
+    style.hbox.box_layout = 'horizontal'
+    style.vbox.box_layout = 'vertical'
+
+    # Motions, zooms, rotozooms, and transforms.
+    style.motion.xanchor = 0
+    style.motion.yanchor = 0
+    style.motion.xpos = 0
+    style.motion.ypos = 0
+    
+    # Windows.
+    style.window.background = Solid((0, 0, 0, 192))
+    style.window.xpadding = 6
+    style.window.ypadding = 6
+    style.window.xmargin = 0
+    style.window.ymargin = 0
+    style.window.xfill = True
+    style.window.yfill = False
+    style.window.yminimum = 150 # Includes margins and padding.
+
+    style.window.xalign = 0.5
+    style.window.yalign = 1.0
+
+    # Image placement.
+    style.image_placement.xpos = 0.5
+    style.image_placement.ypos = 1.0
+    style.image_placement.xanchor = 0.5
+    style.image_placement.yanchor = 1.0
+
+    # Dialogue
+    style.say_label.bold = True
+    style.say_vbox.spacing = 8
+
+    # Two window styles.
+    style.say_who_window.xminimum = 200
+    style.say_who_window.yminimum = 34
+    style.say_who_window.xfill = False
+    style.say_who_window.xalign = 0
+
+    style.say_two_window_vbox.yalign = 1.0
+
+    # Menus.
+    style.menu_choice.idle_color = "#0ff"
+    style.menu_choice.hover_color = "#ff0"
+    style.input_text.color = "#ff0"
+
+    # Styles used by centered.
+    style.centered_window.xalign = 0.5
+    style.centered_window.xfill = False                      
+    style.centered_window.yalign = 0.5
+    style.centered_window.yfill = False
+    style.centered_window.xpadding = 10
+
+    style.centered_text.textalign = 0.5
+    style.centered_text.xalign = 0.5
+    style.centered_text.yalign = 0.5
+    style.centered_text.layout = "subtitle"
+
+    # Hyperlinks.
+    style.hyperlink_text.underline = True
+    style.hyperlink_text.hover_color = "#0ff"
+    style.hyperlink_text.idle_color = "#08f"
+    
+    # Bars.
+    style.default.bar_invert = False
+    style.default.bar_resizing = False
+    style.default.bar_vertical = False
+
+    style.vbar.bar_vertical = True
+    style.vslider.bar_vertical = True
+    style.vscrollbar.bar_vertical = True
+    style.vscrollbar.bar_invert = True
+
+    # Viewport
+    style.viewport.clipping = True
+
+    # Transform
+    style.transform.subpixel = True
+    
+    # Menu windows.
+    style.mm_root.background = "#000"
+    style.mm_root.xfill = True
+    style.mm_root.yfill = True
+
+    style.gm_root.background = "#000"
+    style.gm_root.xfill = True
+    style.gm_root.yfill = True
+
+    # Lists.
+    style.list_row.xfill = True
+
+    style.list_row.ymargin = 0
+    style.list_row.background = "#eee"
+    style.list_row[1].background = "#ddd"
+    style.list_row.hover_background = "#fff"
+    style.list_row[1].hover_background = "#fff"
+    style.list_row.selected_background = "#cce"
+    style.list_row[1].selected_background = "#cce"
+    style.list_text.color = "#000"
+    style.list_text.size = 14
+    style.list_spacer.xminimum = 15
+       
+    
+    ######################################################################
+
+    # Error messages.
+    style.error_root.background = Solid((220, 220, 255, 255))
+    style.error_root.xfill = True
+    style.error_root.yfill = True
+    style.error_root.xpadding = 20
+    style.error_root.ypadding = 20
+
+    style.error_title.color = (255, 128, 128, 255)
+    style.error_body.color = (128, 128, 255, 255)
+

common/00themes.rpy

@@ -0,0 +1,710 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init -1110 python:
+
+    class _Theme(object):
+
+        # Using theme as a decorator is what we do to create a new theme.
+        def __call__(self, func):
+            setattr(self, func.func_name, func)
+            return func
+        
+    _theme = theme = _Theme()
+    del _Theme
+
+    # Public only for compatiblity purposes.
+    def RoundRect(color, small=False):
+        if small:
+            size = 6
+        else:
+            if config.screen_width <= 640:
+                size = 6
+            else:
+                size = 12
+
+        return Frame(theme.OneOrTwoColor("_roundrect/rr%dg.png" % size, color), size, size)
+
+init -1110 python hide:
+
+    @theme
+    def clear_frames():
+        style.frame.clear()
+    
+    @theme
+    def clear_buttons():
+        style.button.clear()
+        style.button_text.clear()
+        style.radio_button.clear()
+        style.radio_button_text.clear()
+        style.check_button.clear()
+        style.check_button_text.clear()
+        style.small_button.clear()
+        style.small_button_text.clear()
+
+    @theme
+    def clear_large_buttons():
+        style.large_button.clear()
+        style.large_button_text.clear()
+
+    @theme
+    def clear_labels():
+        style.label.clear()
+        style.label_text.clear()
+
+    @theme
+    def clear_prompts():
+        style.prompt.clear()
+        style.prompt_text.clear()
+
+    @theme
+    def clear_bars():
+        style.bar.clear()
+        style.vbar.clear()
+        style.scrollbar.clear()
+        style.vscrollbar.clear()
+        style.slider.clear()
+        style.vslider.clear()
+        
+        style.vbar.bar_vertical = True
+        style.vslider.bar_vertical = True
+        style.vscrollbar.bar_vertical = True
+        style.vscrollbar.bar_invert = True
+
+        
+        
+        
+    # This recolors the given image using one or two colors.
+    @theme
+    def OneOrTwoColor(image, color):
+        if len(color) == 2:
+            return im.Twocolor(image, color[0], color[1])
+        else:
+            return im.Twocolor(image, color, color)
+
+    @theme
+    def roundrect_frames(
+        less_rounded,
+        frame):
+
+        theme.clear_frames()
+        
+        style.frame.background = RoundRect(frame, less_rounded)
+
+        style.frame.xpadding = 6
+        style.frame.ypadding = 6
+        
+            
+    @theme
+    def roundrect_buttons(text_size,
+                          less_rounded,
+                          widget,
+                          widget_hover,
+                          widget_text,
+                          widget_selected,
+                          disabled,
+                          disabled_text):
+
+        theme.clear_buttons()
+        
+        style.button.background = RoundRect(widget, less_rounded)
+        style.button.hover_background = RoundRect(widget_hover, less_rounded)
+        style.button.insensitive_background = RoundRect(disabled, less_rounded)
+
+        style.button_text.size = text_size
+        style.button_text.color = widget_text
+        style.button_text.selected_color = widget_selected
+        style.button_text.insensitive_color = disabled_text
+
+        if less_rounded:
+            style.button.xpadding = 6
+        else:
+            style.button.xpadding = 12
+
+        style.button.ypadding = 1
+        style.button.xmargin = 1
+        style.button.ymargin = 1
+
+        style.button_text.xalign = 0.5
+        style.button_text.yalign = 0.5
+        style.button_text.text_align = 0.5
+
+    @theme
+    def roundrect_large_buttons(
+        text_size,
+        less_rounded,
+        widget,
+        widget_hover,
+        widget_text,
+        widget_selected,
+        disabled,
+        disabled_text):
+
+        theme.clear_large_buttons()
+
+        if less_rounded:
+            style.large_button.xpadding = 6
+        else:
+            style.large_button.xpadding = 12
+
+        style.large_button.ypadding = 1
+        style.large_button.xmargin = 1
+        style.large_button.ymargin = 1
+        
+        style.large_button.background = RoundRect(widget, less_rounded)
+        style.large_button.hover_background = RoundRect(widget_hover, less_rounded)
+        style.large_button.insensitive_background = RoundRect(disabled, less_rounded)
+
+        style.large_button_text.size = text_size
+        style.large_button_text.color = widget_text
+        style.large_button_text.selected_color = widget_selected
+        style.large_button_text.insensitive_color = disabled_text
+
+        style.large_button_text.xalign = 0
+        style.large_button_text.yalign = 0
+
+    @theme
+    def roundrect_labels(
+        text_size,
+        label):
+
+        theme.clear_labels()
+        
+        style.label_text.size = text_size
+        style.label_text.color = label
+
+    @theme
+    def roundrect_prompts(
+        text_size,
+        label):
+
+        theme.clear_prompts()
+
+        style.prompt_text.size = text_size
+        style.prompt_text.color = label
+        
+        style.prompt.xalign = 0.5
+        style.prompt_text.text_align = 0.5
+        style.prompt_text.layout = "subtitle"
+        
+    @theme
+    def roundrect_bars(
+        widget,
+        widget_hover):
+
+        theme.clear_bars()
+        
+        def img(name, color, x, y):
+            rv = theme.OneOrTwoColor("_roundrect/" + name + ".png", color)
+            if x is not None:
+                rv = Frame(rv, x, y)
+            return rv
+
+        # Bars.
+        style.bar.ymaximum = 24
+        style.bar.left_gutter = 6
+        style.bar.right_gutter = 6
+        style.bar.thumb_offset = 6
+
+        style.bar.left_bar = img("rrslider_full", widget, 12, 0)
+        style.bar.right_bar = img("rrslider_empty", widget, 12, 0)
+        style.bar.thumb = img("rrslider_thumb", widget, None, None)
+        style.bar.hover_left_bar = img("rrslider_full", widget_hover, 12, 0)
+        style.bar.hover_right_bar = img("rrslider_empty", widget_hover, 12, 0)
+        style.bar.hover_thumb = img("rrslider_thumb", widget_hover, None, None)
+
+        style.vbar.xmaximum = 24
+        style.vbar.top_gutter = 6
+        style.vbar.bottom_gutter = 6
+        style.vbar.thumb_offset = 6
+
+        style.vbar.bottom_bar = img("rrvslider_full", widget, 0, 12)
+        style.vbar.top_bar = img("rrvslider_empty", widget, 0, 12)
+        style.vbar.thumb = img("rrvslider_thumb", widget, None, None)
+        style.vbar.hover_bottom_bar = img("rrvslider_full", widget_hover, 0, 12)
+        style.vbar.hover_top_bar = img("rrvslider_empty", widget_hover, 0, 12)
+        style.vbar.hover_thumb = img("rrvslider_thumb", widget_hover, None, None)
+
+        # Sliders.
+        style.slider.ymaximum = 24
+        style.slider.left_gutter = 6
+        style.slider.right_gutter = 6
+        style.slider.thumb_offset = 6
+
+        style.slider.left_bar = img("rrslider_full", widget, 12, 0)
+        style.slider.right_bar = img("rrslider_empty", widget, 12, 0)
+        style.slider.thumb = img("rrslider_thumb", widget, None, None)
+        style.slider.hover_left_bar = img("rrslider_full", widget_hover, 12, 0)
+        style.slider.hover_right_bar = img("rrslider_empty", widget_hover, 12, 0)
+        style.slider.hover_thumb = img("rrslider_thumb", widget_hover, None, None)
+
+        style.vslider.xmaximum = 24
+        style.vslider.top_gutter = 6
+        style.vslider.bottom_gutter = 6
+        style.vslider.thumb_offset = 6
+
+        style.vslider.bottom_bar = img("rrvslider_full", widget, 0, 12)
+        style.vslider.top_bar = img("rrvslider_empty", widget, 0, 12)
+        style.vslider.thumb = img("rrvslider_thumb", widget, None, None)
+        style.vslider.hover_bottom_bar = img("rrvslider_full", widget_hover, 0, 12)
+        style.vslider.hover_top_bar = img("rrvslider_empty", widget_hover, 0, 12)
+        style.vslider.hover_thumb = img("rrvslider_thumb", widget_hover, None, None)
+
+        
+        # Scrollbars.
+        style.scrollbar.left_gutter = 6
+        style.scrollbar.right_gutter = 6
+        style.scrollbar.thumb_offset = 6
+        style.scrollbar.ymaximum = 12
+
+        style.scrollbar.left_bar = img("rrscrollbar", widget, 12, 0)
+        style.scrollbar.right_bar = img("rrscrollbar", widget, 12, 0)
+        style.scrollbar.thumb = img("rrscrollbar_thumb", widget, None, None)
+        style.scrollbar.hover_left_bar = img("rrscrollbar", widget_hover, 12, 0)
+        style.scrollbar.hover_right_bar = img("rrscrollbar", widget_hover, 12, 0)
+        style.scrollbar.hover_thumb = img("rrscrollbar_thumb", widget_hover, None, None)
+        
+        style.vscrollbar.top_gutter = 6
+        style.vscrollbar.bottom_gutter = 6
+        style.vscrollbar.thumb_offset = 6
+        style.vscrollbar.xmaximum = 12
+
+        style.vscrollbar.left_bar = img("rrvscrollbar", widget, 0, 12)
+        style.vscrollbar.right_bar = img("rrvscrollbar", widget, 0, 12)
+        style.vscrollbar.thumb = img("rrvscrollbar_thumb", widget, None, None)
+        style.vscrollbar.hover_left_bar = img("rrvscrollbar", widget_hover, 0, 12)
+        style.vscrollbar.hover_right_bar = img("rrvscrollbar", widget_hover, 0, 12)
+        style.vscrollbar.hover_thumb = img("rrvscrollbar_thumb", widget_hover, None, None)
+
+    @theme
+    def roundrect(
+        widget = (0, 60, 120, 255),
+        widget_hover = (0, 80, 160, 255),
+        widget_text = (200, 225, 255, 255),
+        widget_selected = (255, 255, 200, 255),
+        disabled = (64, 64, 64, 255),
+        disabled_text = (200, 200, 200, 255),
+        label = (255, 255, 255, 255),
+        frame = (100, 150, 200, 255),
+        window = (0, 0, 0, 192),
+        mm_root = Solid((220, 235, 255, 255)),
+        gm_root = Solid((220, 235, 255, 255)),
+        
+        text_size=None,
+        small_text_size=None,
+        less_rounded = False,        
+        
+        # Compat for the old roundrect theme.
+        window = None,
+        button_menu = None,
+        rounded_window = True,
+        outline_bars = False,
+
+        mm_root = None,
+        gm_root = None):
+
+        if button_menu is None:
+            if (config.script_version is not None) and (config.script_version < (6, 9, 0)):
+                button_menu = True
+            else:
+                button_menu = False
+        
+        layout.defaults()
+        
+        if config.screen_width <= 640:
+            text_size = text_size or 18
+            small_text_size = small_text_size or 12
+            less_rounded = True
+            
+        else:
+            text_size = text_size or 22
+            small_text_size = small_text_size or 16
+            radius = 12
+
+        theme.roundrect_frames(
+            less_rounded,
+            frame)
+
+        theme.roundrect_buttons(
+            text_size,
+            less_rounded,
+            widget,
+            widget_hover,
+            widget_text,
+            widget_selected,
+            disabled,
+            disabled_text)
+
+        theme.roundrect_large_buttons(
+            small_text_size,
+            less_rounded,
+            widget,
+            widget_hover,
+            widget_text,
+            widget_selected,
+            disabled,
+            disabled_text)
+
+        theme.roundrect_labels(
+            text_size,
+            label)
+
+        theme.roundrect_prompts(
+            text_size,
+            label)
+
+        theme.roundrect_bars(
+            widget,
+            widget_hover)
+            
+        if mm_root is not None:
+            style.mm_root.background = mm_root
+
+        if gm_root is not None:
+            style.gm_root.background = gm_root
+            
+        if window is not None:
+
+            if rounded_window:
+                style.window.background = RoundRect(window, less_rounded)
+                style.window.xpadding = 6
+                style.window.xmargin = 6
+                style.window.ypadding = 6
+                style.window.ymargin = 6
+            else:
+                style.window.background = Solid(window)
+                style.window.xpadding = 6
+                style.window.xmargin = 0
+                style.window.ypadding = 6
+                style.window.ymargin = 0
+
+
+        if button_menu:
+            layout.button_menu()
+
+    @theme
+    def ancient():
+
+        layout.defaults()
+        
+        style.frame.background = Solid((0, 0, 128, 128))
+        style.frame.xpadding = 10
+        style.frame.ypadding = 10
+        style.frame.xmargin = 10
+        style.frame.ymargin = 5
+        
+        style.menu_frame.set_parent(style.default)
+        
+        dark_cyan = (0, 192, 255, 255)
+        bright_cyan = (0, 255, 255, 255)
+        dark_red = (255, 128, 128, 255)
+        bright_red = (255, 64, 64, 255)
+        green = (0, 128, 0, 255)
+        
+        style.button_text.color = dark_cyan
+        style.button_text.hover_color = bright_cyan
+        style.button_text.insensitive_color = (192, 192, 192, 255)
+        style.button_text.size = 24
+        style.button_text.drop_shadow = (2, 2)        
+        style.button_text.drop_shadow_color = "#000"
+        
+        style.button_text.selected_color = dark_red
+        style.button_text.selected_hover_color = bright_red
+        
+        style.button_text.xalign = 0.5
+        style.button_text.text_align = 0.5
+        
+        style.bar.ymaximum = 22
+        style.bar.left_bar = Solid(bright_cyan)
+        style.bar.right_bar = Solid((0, 0, 0, 128))
+        style.bar.thumb = None
+        style.bar.thumb_offset = 0
+        style.bar.thumb_shadow = None
+
+        style.vbar.xmaximum = 22
+        style.vbar.bottom_bar = Solid(bright_cyan)
+        style.vbar.top_bar = Solid((0, 0, 0, 128))
+        style.vbar.thumb = None
+        style.vbar.thumb_offset = 0
+        style.vbar.thumb_shadow = None
+
+        style.slider.ymaximum = 22
+        style.slider.left_bar = Solid(bright_cyan)
+        style.slider.right_bar = Solid((0, 0, 0, 128))
+        style.slider.thumb = None
+        style.slider.thumb_offset = 0
+        style.slider.thumb_shadow = None
+
+        style.vslider.xmaximum = 22
+        style.vslider.bottom_bar = Solid(bright_cyan)
+        style.vslider.top_bar = Solid((0, 0, 0, 128))
+        style.vslider.thumb = None
+        style.vslider.thumb_offset = 0
+        style.vslider.thumb_shadow = None
+
+        style.scrollbar.ymaximum = 22
+        style.scrollbar.left_bar = Solid("#0008")
+        style.scrollbar.right_bar = Solid("#0008")
+        style.scrollbar.thumb = Solid(bright_cyan)
+        style.scrollbar.thumb_offset = 0
+        style.scrollbar.thumb_shadow = None
+
+        style.vscrollbar.xmaximum = 22
+        style.vscrollbar.top_bar = Solid("#0008")
+        style.vscrollbar.bottom_bar = Solid("#0008")
+        style.vscrollbar.thumb = Solid(bright_cyan)
+        style.vscrollbar.thumb_offset = 0
+        style.vscrollbar.thumb_shadow = None
+
+        style.large_button.xpadding = 5
+        style.large_button.ypadding = 2
+        style.large_button.xmargin = 5
+        style.large_button.ymargin = 2
+        style.large_button.background = "#fff"
+        style.large_button.hover_background = "#ffc"
+
+        style.large_button_text.size = 16
+        style.large_button_text.drop_shadow = (1, 1)
+        style.large_button_text.xalign = 0
+        style.large_button_text.text_align = 0
+
+        style.label_text.size = 24
+        style.label_text.color = green
+        style.label_text.drop_shadow = (1, 1)
+        style.label_text.drop_shadow_color = "#000"
+
+        style.prompt_text.size = 24
+        style.prompt_text.color = green
+        style.prompt_text.layout = "subtitle"
+        style.prompt_text.text_align = 0.5
+        style.prompt_text.drop_shadow = (1, 1)
+        style.prompt_text.drop_shadow_color = "#000"
+
+        style.mm_root.background = "#e9d8bc"
+        style.gm_root.background = "#e9d8bc"
+
+
+    @theme
+    def outline_frames():
+        theme.clear_frames()
+
+    @theme
+    def outline_buttons(
+        inside,
+        idle,
+        hover,
+        selected,
+        insensitive,
+        text_size):
+
+        theme.clear_buttons()
+
+        style.button.xmargin = 4
+        
+        style.button_text.size = text_size
+        style.button_text.color = inside
+        style.button_text.outlines = [ (2, idle) ]
+        style.button_text.hover_outlines = [ (2, hover) ]
+        style.button_text.selected_outlines = [ (2, selected) ]
+        style.button_text.selected_hover_outlines = [ (2, hover) ]
+        style.button_text.insensitive_outlines = [ (2, insensitive) ]
+        
+
+    @theme
+    def outline_large_buttons(
+        inside,
+        idle,
+        hover,
+        selected,
+        insensitive,
+        text_size,
+        large_button):
+
+        theme.clear_large_buttons()
+
+        style.large_button.xmargin = 4
+        style.large_button.ymargin = 2
+
+        style.large_button.background = large_button
+        
+        style.large_button_text.size = text_size
+        style.large_button_text.color = inside
+
+        style.large_button_text.outlines = [ (2, idle) ]
+        style.large_button_text.hover_outlines = [ (2, hover) ]
+        style.large_button_text.selected_outlines = [ (2, selected) ]
+        style.large_button_text.selected_hover_outlines = [ (2, hover) ]
+        style.large_button_text.insensitive_outlines = [ (2, insensitive) ]
+        
+    @theme
+    def outline_prompts(
+        inside,
+        prompt,
+        text_size):
+
+        theme.clear_prompts()
+        
+        style.prompt_text.color = inside
+        style.prompt_text.outlines = [ (2, prompt) ]
+        style.prompt_text.size = text_size
+        
+    @theme
+    def outline_labels(
+        inside,
+        label,
+        text_size):
+
+        theme.clear_labels()
+        
+        style.label_text.color = inside
+        style.label_text.outlines = [ (2, label) ]
+        style.label_text.size = text_size
+        
+    @theme
+    def outline_bars(        
+        inside,
+        idle,
+        hover):
+
+        theme.clear_bars()
+        
+        def color(fn, c):
+            return im.Twocolor("_outline/" + fn + ".png", inside, c)
+
+        style.bar.ymaximum = 16
+        style.bar.left_bar = Frame(color("circle", idle), 7, 0)
+        style.bar.right_bar = Frame(color("bar", idle), 0, 0)
+        style.bar.left_gutter = 16
+        style.bar.bar_resizing = True
+        
+        style.slider.ymaximum = 16
+        style.slider.left_bar = Frame(color("bar", idle), 0, 0)
+        style.slider.right_bar = Frame(color("bar", idle), 0, 0)
+        style.slider.thumb = color("circle", idle)
+        style.slider.hover_left_bar = Frame(color("bar", hover), 0, 0)
+        style.slider.hover_right_bar = Frame(color("bar", hover), 0, 0)
+        style.slider.hover_thumb = color("circle", hover)
+
+        style.scrollbar.ymaximum = 16
+        style.scrollbar.left_bar = Frame(color("bar", idle), 0, 0)
+        style.scrollbar.right_bar = Frame(color("bar", idle), 0, 0)
+        style.scrollbar.thumb = Frame(color("circle", idle), 7, 0)
+        style.scrollbar.hover_left_bar = Frame(color("bar", hover), 0, 0)
+        style.scrollbar.hover_right_bar = Frame(color("bar", hover), 0, 0)
+        style.scrollbar.hover_thumb = Frame(color("circle", hover), 7, 0)
+        
+        style.vbar.xmaximum = 16
+        style.vbar.bottom_bar = Frame(color("circle", idle), 0, 7)
+        style.vbar.top_bar = Frame(color("vbar", idle), 0, 0)
+        style.vbar.bottom_gutter = 16
+        style.vbar.bar_resizing = True
+
+        style.vslider.xmaximum = 16
+        style.vslider.top_bar = Frame(color("vbar", idle), 0, 0)
+        style.vslider.bottom_bar = Frame(color("vbar", idle), 0, 0)
+        style.vslider.thumb = color("circle", idle)
+        style.vslider.hover_top_bar = Frame(color("vbar", hover), 0, 0)
+        style.vslider.hover_bottom_bar = Frame(color("vbar", hover), 0, 0)
+        style.vslider.hover_thumb = color("circle", hover)
+
+        style.vscrollbar.xmaximum = 16
+        style.vscrollbar.top_bar = Frame(color("vbar", idle), 0, 0)
+        style.vscrollbar.bottom_bar = Frame(color("vbar", idle), 0, 0)
+        style.vscrollbar.thumb = Frame(color("circle", idle), 0, 7)
+        style.vscrollbar.hover_top_bar = Frame(color("vbar", hover), 0, 0)
+        style.vscrollbar.hover_bottom_bar = Frame(color("vbar", hover), 0, 0)
+        style.vscrollbar.hover_thumb = Frame(color("circle", hover), 0, 7)
+
+    @theme
+    def outline(
+        inside="#fff",
+        idle="#e66",
+        hover="#48f",
+        selected="#84f",
+        insensitive="#ccc",
+        label="#484",
+        prompt="#484",
+        background="#fee",
+        large_button="#fff8f8",
+        text_size=22,
+        small_text_size=16,
+        ):
+
+        layout.defaults()
+
+        theme.outline_frames()
+        
+        theme.outline_buttons(
+            inside,
+            idle,
+            hover,
+            selected,
+            insensitive,
+            text_size)
+
+        theme.outline_large_buttons(
+            inside,
+            idle,
+            hover,
+            selected,
+            insensitive,
+            small_text_size,
+            large_button)
+
+        theme.outline_prompts(
+            inside,
+            prompt,
+            text_size)
+
+        theme.outline_labels(
+            inside,
+            label,
+            text_size)
+
+        theme.outline_bars(
+            inside,
+            idle,
+            hover)
+
+        style.mm_root.background = background
+        style.gm_root.background = background
+        
+    @theme
+    def image_buttons(d):
+        for k, (idle, hover, selected_idle, selected_hover, insensitive) in d.iteritems():
+            s = style.button[k]
+            s.xpadding = 0
+            s.ypadding = 0
+            s.background = None
+            s.foreground = None
+            s.idle_child = idle
+            s.hover_child = hover
+            s.selected_idle_child = selected_idle
+            s.selected_hover_child = selected_hover
+            s.insensitive_child = insensitive 
+            s.focus_mask = True
+            
+
+    @theme
+    def image_labels(d):
+        for k, l in d.iteritems():
+            s = style.label[k]
+            s.xpadding = 0
+            s.ypadding = 0
+            s.background = None
+            s.foreground = None
+            s.child = k
+
+            
+    config.image_buttons = { }
+    config.image_labels = { }
+
+init 1110 python:
+
+    if not "compat" in _layout.provided:
+        theme.image_buttons(config.image_buttons)
+        theme.image_labels(config.image_labels)
+        
+    
+    
+        

common/00voice.rpy

@@ -0,0 +1,131 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This extra contains a basic implementation of voice support. Right
+# now, voice is given its own toggle, and can either be turned on or
+# turned off. In the future, we'll probably provide some way of
+# toggling it on or off for individual characters.
+#
+# To use it, place a voice "<sndfile>" line before each voiced line of
+# dialogue.
+#
+#     voice "e_1001.ogg"
+#     e "Voice support lets you add the spoken word to your games."
+#
+# Normally, a voice is cancelled at the start of the next
+# interaction. If you want a voice to span interactions, call
+# voice_sustain.
+#
+#     voice "e_1002.ogg"
+#     e "Voice sustain is a technique that allows the same voice file.."
+#
+#     $ voice_sustain()
+#     e "...to play for two lines of dialogue."
+
+init -1120:
+
+    python:
+
+        _voice = object()
+        _voice.play = None
+        _voice.sustain = False
+        _voice.seen_in_lint = False
+
+        # Call this to specify the voice file that will be played for
+        # the user.
+        def voice(file, **kwargs):
+
+            if not config.has_voice:
+                return
+            
+            _voice.play = file
+            _last_voice_play = file 
+            
+        # Call this to specify that the currently playing voice file
+        # should be sustained through the current interaction.
+        def voice_sustain(ignored="", **kwargs):
+            if not config.has_voice:
+                return
+            
+            _voice.sustain = True
+
+        # Call this to replay the last bit of voice.
+        def voice_replay():
+            renpy.sound.play(_last_voice_play, channel=2)
+
+        # Returns true if we can replay the voice.
+        def voice_can_replay():
+            return _last_voice_play != None
+            
+    python hide:
+
+        # basics: True if the game will have voice.
+        config.has_voice = True
+
+        # This is called on each interaction, to ensure that the
+        # appropriate voice file is played for the user.        
+        def voice_interact():
+            
+            if not config.has_voice:
+                return
+            
+            if _voice.play and not config.skipping:
+                renpy.sound.play(_voice.play, channel=2)
+                store._last_voice_play = _voice.play        
+            elif not _voice.sustain:
+                renpy.sound.stop(channel=2)
+                store._last_voice_play = _voice.play        
+
+            _voice.play = None
+            _voice.sustain = False
+        
+        config.start_interact_callbacks.append(voice_interact)
+        config.say_sustain_callbacks.append(voice_sustain)
+
+        def voice_afm_callback():
+            return not renpy.sound.is_playing(channel=2)
+
+        config.afm_callback = voice_afm_callback
+                       
+python early hide:
+
+    def parse_voice(l):
+        fn = l.simple_expression()
+        if fn is None:
+            renpy.error('expected simple expression (string)')
+
+        if not l.eol():
+            renpy.error('expected end of line')
+
+        return fn
+
+    def execute_voice(fn):
+        fn = eval(fn)
+        voice(fn)
+
+    def lint_voice(fn):
+        _voice.seen_in_lint = True
+
+        fn = _try_eval(fn, 'voice filename')
+        if isinstance(fn, basestring) and not renpy.loadable(fn):
+            renpy.error('voice file %r is not loadable' % fn)
+
+    renpy.statements.register('voice',
+                              parse=parse_voice,
+                              execute=execute_voice,
+                              lint=lint_voice)
+
+    def parse_voice_sustain(l):
+        if not l.eol():
+            renpy.error('expected end of line')
+
+        return None
+
+    def execute_voice_sustain(parsed):
+        voice_sustain()
+
+    renpy.statements.register('voice sustain',
+                              parse=parse_voice_sustain,
+                              execute=execute_voice_sustain)
+
+

common/DejaVuSans.txt

@@ -0,0 +1,99 @@
+Fonts are (c) Bitstream (see below). DejaVu changes are in public domain.
+Glyphs imported from Arev fonts are (c) Tavmjong Bah (see below)
+
+Bitstream Vera Fonts Copyright
+------------------------------
+
+Copyright (c) 2003 by Bitstream, Inc. All Rights Reserved. Bitstream Vera is
+a trademark of Bitstream, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of the fonts accompanying this license ("Fonts") and associated
+documentation files (the "Font Software"), to reproduce and distribute the
+Font Software, including without limitation the rights to use, copy, merge,
+publish, distribute, and/or sell copies of the Font Software, and to permit
+persons to whom the Font Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright and trademark notices and this permission notice shall
+be included in all copies of one or more of the Font Software typefaces.
+
+The Font Software may be modified, altered, or added to, and in particular
+the designs of glyphs or characters in the Fonts may be modified and
+additional glyphs or characters may be added to the Fonts, only if the fonts
+are renamed to names not containing either the words "Bitstream" or the word
+"Vera".
+
+This License becomes null and void to the extent applicable to Fonts or Font
+Software that has been modified and is distributed under the "Bitstream
+Vera" names.
+
+The Font Software may be sold as part of a larger software package but no
+copy of one or more of the Font Software typefaces may be sold by itself.
+
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT,
+TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL BITSTREAM OR THE GNOME
+FOUNDATION BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING
+ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE
+FONT SOFTWARE.
+
+Except as contained in this notice, the names of Gnome, the Gnome
+Foundation, and Bitstream Inc., shall not be used in advertising or
+otherwise to promote the sale, use or other dealings in this Font Software
+without prior written authorization from the Gnome Foundation or Bitstream
+Inc., respectively. For further information, contact: fonts at gnome dot
+org. 
+
+Arev Fonts Copyright
+------------------------------
+
+Copyright (c) 2006 by Tavmjong Bah. All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the fonts accompanying this license ("Fonts") and
+associated documentation files (the "Font Software"), to reproduce
+and distribute the modifications to the Bitstream Vera Font Software,
+including without limitation the rights to use, copy, merge, publish,
+distribute, and/or sell copies of the Font Software, and to permit
+persons to whom the Font Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright and trademark notices and this permission notice
+shall be included in all copies of one or more of the Font Software
+typefaces.
+
+The Font Software may be modified, altered, or added to, and in
+particular the designs of glyphs or characters in the Fonts may be
+modified and additional glyphs or characters may be added to the
+Fonts, only if the fonts are renamed to names not containing either
+the words "Tavmjong Bah" or the word "Arev".
+
+This License becomes null and void to the extent applicable to Fonts
+or Font Software that has been modified and is distributed under the 
+"Tavmjong Bah Arev" names.
+
+The Font Software may be sold as part of a larger software package but
+no copy of one or more of the Font Software typefaces may be sold by
+itself.
+
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL
+TAVMJONG BAH BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
+
+Except as contained in this notice, the name of Tavmjong Bah shall not
+be used in advertising or otherwise to promote the sale, use or other
+dealings in this Font Software without prior written authorization
+from Tavmjong Bah. For further information, contact: tavmjong @ free
+. fr.
+
+$Id: LICENSE 2133 2007-11-28 02:46:28Z lechimp $

common/Vera.txt

@@ -1,55 +0,0 @@
-This package was debianized by Michael Fedrowitz <michaelf@debian.org>
-on Sun, 23 Feb 2003.
-
-It was downloaded from
-'http://ftp.gnome.org/pub/GNOME/sources/ttf-bitstream-vera/'.
-
-Upstream Author: Bitstream, Inc.
-
-Copyright:
-
-   Copyright (c) 2003 by Bitstream, Inc. All Rights Reserved. Bitstream
-   Vera is a trademark of Bitstream, Inc.
-
-   Permission is hereby granted, free of charge, to any person obtaining
-   a copy of the fonts accompanying this license ("Fonts") and associated
-   documentation files (the "Font Software"), to reproduce and distribute
-   the Font Software, including without limitation the rights to use,
-   copy, merge, publish, distribute, and/or sell copies of the Font
-   Software, and to permit persons to whom the Font Software is furnished
-   to do so, subject to the following conditions:
-
-   The above copyright and trademark notices and this permission notice
-   shall be included in all copies of one or more of the Font Software
-   typefaces.
-
-   The Font Software may be modified, altered, or added to, and in
-   particular the designs of glyphs or characters in the Fonts may be
-   modified and additional glyphs or characters may be added to the
-   Fonts, only if the fonts are renamed to names not containing either
-   the words "Bitstream" or the word "Vera".
-
-   This License becomes null and void to the extent applicable to Fonts
-   or Font Software that has been modified and is distributed under the
-   "Bitstream Vera" names.
-
-   The Font Software may be sold as part of a larger software package but
-   no copy of one or more of the Font Software typefaces may be sold by
-   itself.
-
-   THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-   OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL
-   BITSTREAM OR THE GNOME FOUNDATION BE LIABLE FOR ANY CLAIM, DAMAGES OR
-   OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL,
-   OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-   OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT
-   SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.
-
-   Except as contained in this notice, the names of Gnome, the Gnome
-   Foundation, and Bitstream Inc., shall not be used in advertising or
-   otherwise to promote the sale, use or other dealings in this Font
-   Software without prior written authorization from the Gnome Foundation
-   or Bitstream Inc., respectively. For further information, contact:
-   fonts at gnome dot org.

common/_compat/gamemenu.rpym

@@ -0,0 +1,504 @@
+# Copyright 2004-2008 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    ######################################################################
+    # First up, we define a bunch of configuration variable, which the
+    # user can change.
+
+    # The contents of the game menu choices.
+    config.game_menu = [
+            ( "return", u"Return", ui.jumps("_return"), 'True'),
+            ( "skipping", u"Begin Skipping", ui.jumps("_return_skipping"), 'config.allow_skipping and not renpy.context().main_menu'),
+            ( "prefs", u"Preferences", _intra_jumps("_prefs_screen", "intra_transition"), 'True' ),
+            ( "save", u"Save Game", _intra_jumps("_save_screen", "intra_transition"), 'not renpy.context().main_menu' ),
+            ( "load", u"Load Game", _intra_jumps("_load_screen", "intra_transition"), 'True'),
+            ( "mainmenu", u"Main Menu", lambda : _mainmenu_prompt(), 'not renpy.context().main_menu' ),
+            ( "quit", u"Quit", lambda : _quit_prompt("quit"), 'True' ),
+            ]
+
+    # If not None, a map from the names of the game menu
+    # navigation buttons to new fixed positions for them on
+    # the screen.
+    config.game_menu_positions = None
+
+    # The number of columns of files to show at once.
+    config.file_page_cols = 2
+
+    # The number of rows of files to show at once.
+    config.file_page_rows = 5
+
+    # The number of pages to add quick access buttons for.
+    config.file_quick_access_pages = 5
+
+    # The positions of file picker components.
+    config.file_picker_positions = None
+
+    
+    # This lets us disable the file pager. (So we only have one
+    # page of files.)
+    config.disable_file_pager = False
+
+    # This lets us disable the thumbnails in the file pager.
+    config.disable_thumbnails = False
+
+    # How we format time.
+    config.time_format = "%b %d, %H:%M"
+
+    # How we format loade_save slot formats.
+    config.file_entry_format = "%(time)s\n%(save_name)s"
+
+    # If True, we will be prompted before loading a game. (This can
+    # be changed from inside the game code, so that one can load from
+    # the first few screens but not after that.)
+    _load_prompt = True
+
+    
+    _game_menu_screen = "_save_screen"
+
+    ######################################################################
+    # Next, support code.
+
+    # This is used to store scratch data that's used by the
+    # library, but shouldn't be saved out as part of the savegame.
+    _scratch = object()
+
+    # This returns a window containing the game menu navigation
+    # buttons, set up to jump to the appropriate screen sections.
+    #
+    # This can be overridden by user code. It's called with the
+    # name of the selected screen... one of "mainmenu", "prefs",
+    # "save", "load", or "quit", at least for the default game
+    # menu. If None, then it's an indication that none of the
+    # nav buttons should be shown.
+    def _game_nav(screen, buttons=True):
+
+        global _screen
+        _screen = screen
+
+        ui.add(renpy.Keymap(toggle_fullscreen = renpy.toggle_fullscreen))
+        ui.add(renpy.Keymap(game_menu=ui.jumps("_noisy_return")))
+
+        ui.window(style=style.gm_root[screen])
+        ui.null()
+
+        if not screen:
+            return
+
+        if not config.game_menu_positions:
+            ui.window(style='gm_nav_frame')
+            ui.vbox(focus='gm_nav', style='gm_nav_vbox')
+
+        for i, (key, label, clicked, enabled) in enumerate(config.game_menu):
+
+            disabled = False
+
+            if not eval(enabled):
+                disabled = True
+                clicked = None
+
+            if config.game_menu_positions:
+                kwargs = config.game_menu_positions.get(label, { })
+            else:
+                kwargs = { }
+
+            _button_factory(label, "gm_nav",
+                            selected=(key==screen),
+                            disabled=disabled,
+                            clicked=clicked,
+                            properties=kwargs)
+
+        if not config.game_menu_positions:
+            ui.close()
+
+    # This is called from the game menu to interact with the
+    # user.  It suppresses all of the underlays and overlays.
+    def _game_interact():
+
+        return ui.interact(suppress_underlay=True,
+                           suppress_overlay=True,
+                           mouse="gamemenu")
+
+
+    # This renders a slot with a file in it, in the file picker.
+    def _render_savefile(index, name, filename, extra_info, screenshot, mtime, newest, clickable, **positions):
+
+        if clickable:
+            clicked = ui.returns(("return", (filename, True)))
+        else:
+            clicked = None
+
+        ui.button(style=style.file_picker_entry[index],
+                  clicked=clicked,
+                  **positions)
+
+        ui.hbox(style=style.file_picker_entry_box[index])
+
+        if not config.disable_thumbnails:
+            ui.add(screenshot)
+
+        if newest:
+            ui.text(name + ". ", style=style.file_picker_new[index])
+        else:
+            ui.text(name + ". ", style=style.file_picker_old[index])
+
+
+        s = config.file_entry_format % dict(
+            time=renpy.time.strftime(config.time_format,
+                                     renpy.time.localtime(mtime)),
+            save_name=extra_info)
+
+        ui.text(s, style=style.file_picker_extra_info[index])
+
+        ui.close()
+
+    # This renders an empty slot in the file picker.
+    def _render_new_slot(index, name, filename, clickable, **positions):
+
+        if clickable:
+            clicked=ui.returns(("return", (filename, False)))
+            enable_hover = True
+        else:
+            clicked = None
+            enable_hover = True
+
+        ui.button(style=style.file_picker_entry[index],
+                  clicked=clicked,
+                  enable_hover=enable_hover,
+                  **positions)
+
+        ui.hbox(style=style.file_picker_entry_box[index])
+
+        if not config.disable_thumbnails:
+            ui.null(width=config.thumbnail_width,
+                    height=config.thumbnail_height)
+
+
+        ui.text(name + ". ", style=style.file_picker_old[index])
+
+        ui.text(_(u"Empty Slot."), style=style.file_picker_empty_slot[index])
+        ui.close()
+
+    _scratch.file_picker_page = None
+
+    # The names of the various pages that the file picker knows
+    # about.
+    def _file_picker_pages():
+
+        rv = [ ]
+
+        if config.has_autosave:
+            rv.append("Auto")
+
+        if config.has_quicksave:
+            rv.append("Quick")
+
+        for i in range(1, config.file_quick_access_pages + 1):
+            rv.append(str(i))
+
+        return rv
+
+
+    # This function is given a page, and should map it to the names
+    # of the files on that page.
+    def _file_picker_page_files(page):
+
+        per_page = config.file_page_cols * config.file_page_rows
+        rv = [ ]
+
+        if config.has_autosave:
+            if page == 0:
+                for i in range(1, per_page + 1):
+                    rv.append(("auto-" + str(i), "a" + str(i), True))
+
+                return rv
+            else:
+                page -= 1
+
+        if config.has_quicksave:
+            if page == 0:
+                for i in range(1, per_page + 1):
+                    rv.append(("quick-" + str(i), "q" + str(i), True))
+
+                return rv
+            else:
+                page -= 1
+
+        for i in range(per_page * page + 1, per_page * page + 1 + per_page):
+            rv.append(("%d" % i, "%d" % i, False))
+
+        return rv
+
+    # Given a filename, returns the page that filename is on. 
+    def _file_picker_file_page(filename):
+
+        per_page = config.file_page_cols * config.file_page_rows
+
+        base = 0
+
+        if config.has_autosave:
+            if filename.startswith("auto-"):
+                return base
+            else:
+                base += 1
+
+        if config.has_quicksave:
+            if filename.startswith("quick-"):
+                return base
+            else:
+                base += 1
+
+        return base + int((int(filename) - 1) / per_page)
+
+
+    def _file_picker_process_screenshot(s):
+        return s
+    
+    # This displays a file picker that can chose a save file from
+    # the list of save files.
+    def _file_picker(selected, save):
+
+        # The number of slots in a page.
+        file_page_length = config.file_page_cols * config.file_page_rows
+
+        saved_games = renpy.list_saved_games(regexp=r'(auto-|quick-)?[0-9]+')
+
+        newest = None
+        newest_mtime = None
+        save_info = { }
+
+        for fn, extra_info, screenshot, mtime in saved_games:
+            screenshot = _file_picker_process_screenshot(screenshot)
+            save_info[fn] = (extra_info, screenshot, mtime)
+
+            if not fn.startswith("auto-") and mtime > newest_mtime:
+                newest = fn
+                newest_mtime = mtime
+
+        if config.file_picker_positions:
+            positions = config.file_picker_positions
+        else:
+            positions = { }
+
+        # The index of the first entry in the page.
+        fpp = _scratch.file_picker_page
+
+        if fpp is None:
+
+            if newest:
+                fpp = _file_picker_file_page(newest)
+            else:
+                fpp = _file_picker_file_page("1")
+
+
+        while True:
+
+            if fpp < 0:
+                fpp = 0
+
+            _scratch.file_picker_page = fpp
+
+            # Show navigation
+            _game_nav(selected)
+
+            if not config.file_picker_positions:
+
+                ui.window(style='file_picker_frame')
+                ui.vbox(style='file_picker_frame_vbox') # whole thing.
+
+            if not config.disable_file_pager:
+
+                ### file_picker_navbox thick_hbox
+                # (box) The box containing the naviation (next/previous)
+                # buttons in the file picker.
+
+                ### file_picker_nav_button menu_button
+                # (window, hover) The style that is used for enabled file
+                # picker navigation buttons.
+
+                ### file_picker_nav_button_text menu_button_text
+                # (text) The style that is used for the label of enabled
+                # file picker navigation buttons.
+
+                # Draw the navigation.
+                if not config.file_picker_positions:
+                    ui.hbox(style='file_picker_navbox') # nav buttons.
+
+                def tb(cond, label, clicked, selected):
+                    _button_factory(label,
+                                    "file_picker_nav",
+                                    disabled=not cond,
+                                    clicked=clicked,
+                                    selected=selected,
+                                    properties=positions.get("nav_" + label, { }))
+
+                # Previous
+                tb(fpp > 0, _(u'Previous'), ui.returns(("fppdelta", -1)), selected=False)
+    
+                # Quick Access
+                for i, name in enumerate(_file_picker_pages()):
+                    tb(True, name, ui.returns(("fppset", i)), fpp == i)
+
+                # Next
+                tb(True, _(u'Next'), ui.returns(("fppdelta", +1)), False)
+
+                # Done with nav buttons.
+                if not config.file_picker_positions:
+                    ui.close()
+
+            # This draws a single slot.
+            def entry(name, filename, offset, ro):
+                place = positions.get("entry_" + str(offset + 1), { })
+
+                if filename not in save_info:
+                    clickable = save and not ro
+
+                    _render_new_slot(offset, name, filename, clickable, **place)
+                else:
+                    clickable = not save or not ro
+
+                    extra_info, screenshot, mtime = save_info[filename]
+                    _render_savefile(offset, name, filename, extra_info, screenshot,
+                                     mtime, newest == filename, clickable, **place)
+
+            if not config.file_picker_positions:
+                ui.grid(config.file_page_cols,
+                        config.file_page_rows,
+                        style='file_picker_grid',
+                        transpose=True) # slots
+
+            for i, (filename, name, ro) in enumerate(_file_picker_page_files(fpp)):
+                entry(name, filename, i, ro)
+
+            if not config.file_picker_positions:                    
+                ui.close() # slots
+                ui.close() # whole thing
+
+            result = _game_interact()
+            type, value = result
+
+            if type == "return":
+                return value
+
+            if type == "fppdelta":
+                fpp += value
+
+            if type == "fppset":
+                fpp = value
+
+
+    # This renders a yes/no prompt, as part of the game menu. If
+    # screen is None, then it omits the game menu navigation. 
+    def _yesno_prompt(screen, message):
+        """
+        @param screen: The screen button that should be highlighted when this prompt is shown. If None, then no game menu navigation is shown.
+
+        @param message: The message that is shown to the user to prompt them to answer yes or no.
+
+        This function returns True if the user clicks Yes, or False if the user clicks No.
+        """
+
+        renpy.transition(config.intra_transition)
+
+        _game_nav(screen)
+
+        ui.window(style='yesno_frame')
+        ui.vbox(style='yesno_frame_vbox')
+
+        _label_factory(message, "yesno")
+
+        ui.hbox(style='yesno_button_hbox')
+        
+        # The extra nulls are because we want equal whitespace surrounding
+        # the two buttons. It should work as long as we have xfill=True
+        _button_factory(u"Yes", 'yesno', clicked=ui.returns(True))
+        _button_factory(u"No", 'yesno', clicked=ui.returns(False))
+
+        ui.close()
+        ui.close()
+
+        rv =  _game_interact()
+        renpy.transition(config.intra_transition)
+        return rv
+
+    config.old_names["Are you sure you want to quit?"] = "Are you sure you want to quit the game?"
+
+    def _quit_prompt(screen="quit"):
+
+        def prompt():
+           return _yesno_prompt(screen, u"Are you sure you want to quit?")
+
+        if renpy.invoke_in_new_context(prompt):
+            renpy.quit()
+        else:
+            return
+
+    config.old_names["Are you sure you want to return to the main menu?\nThis will lose unsaved progress."] = "Are you sure you want to return to the main menu?\nThis will end your game."
+
+    def _mainmenu_prompt(screen="mainmenu"):
+
+        def prompt():
+           return _yesno_prompt(screen, u"Are you sure you want to return to the main menu?\nThis will lose unsaved progress.")
+
+        if renpy.invoke_in_new_context(prompt):
+            renpy.full_restart(transition=config.game_main_transition)
+        else:
+            return
+        
+label _compat_confirm_quit:
+    $ _quit_prompt(None)
+    return
+
+
+init -1160:
+    $ config.old_names["Loading will lose unsaved progress.\nAre you sure you want to do this?"] = "Loading a new game will end your current game.\nAre you sure you want to do this?"
+
+label _load_screen:
+
+    if renpy.has_label("_load_screen_hook"):
+        call expression "_load_screen_hook" from _call__load_screen_hook
+    
+    python hide:
+
+        fn, exists = _file_picker("load", False )
+
+        if not renpy.context().main_menu and _load_prompt:
+            if _yesno_prompt("load", u"Loading will lose unsaved progress.\nAre you sure you want to do this?"):
+                renpy.load(fn)
+        else:                        
+            renpy.load(fn)
+
+    jump _load_screen
+
+label _save_screen:
+    
+    if renpy.has_label("_save_screen_hook"):
+        call expression "_save_screen_hook" from _call__save_screen_hook
+
+    $ _fn, _exists = _file_picker("save", True)
+
+    if not _exists or _yesno_prompt("save", u"Are you sure you want to overwrite your save?"):
+        python hide:
+
+            if save_name:
+                full_save_name = save_name
+            else:
+                full_save_name = ""
+
+            try:
+                renpy.save(_fn, full_save_name)
+
+            except Exception, e:
+
+                if config.debug:
+                    raise
+                
+                message = ( _(u"The error message was:") + "\n\n" + 
+                            e.__class__.__name__  + ": " + unicode(e) + "\n\n" +
+                            _(u"You may want to try saving in a different slot, or playing for a while and trying again later.") )
+
+                _show_exception(_(u"Save Failed."), message)
+                
+                
+    jump _save_screen

common/_compat/library.rpym

@@ -0,0 +1,112 @@
+# Copyright 2004-2008 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init:
+    python:
+
+        # A dict of 5-tuples mapping button labels to image buttons.
+        config.image_buttons = { }
+
+        # A dict mapping label to image.
+        config.image_labels = { }
+
+        # Maps from button or label to additional properties.
+        config.button_properties = { }
+        config.button_text_properties = { }
+        config.label_properties = { }
+
+        def _button_factory(label,
+                            type=None,
+                            selected=None,
+                            disabled=False,
+                            clicked=None,
+                            properties={},
+                            index=None,
+                            **props):
+            """
+            This function is called to create the various buttons used
+            in the game menu. By overriding this function, one can
+            (for example) replace the default textbuttons with image buttons.
+            When it is called, it's expected to add a button to the screen.
+
+            @param label: The label of this button, before translation. 
+
+            @param type: The type of the button. One of "mm" (main menu),
+            "gm_nav" (game menu), "file_picker_nav", "yesno", or "prefs".
+
+            @param selected: True if the button is selected, False if not,
+            or None if it doesn't matter.
+
+            @param disabled: True if the button is disabled, False if not.
+
+            @param clicked: A function that should be executed when the
+            button is clicked.
+
+            @param properties: Addtional layout properties.
+            """
+
+            props.update(properties)
+            props.update(config.button_properties.get(label, { }))
+            
+            if disabled:
+                clicked = None
+
+            if selected and not disabled:
+                role = "selected_"
+            else:
+                role = ""
+
+                
+            if label in config.image_buttons:
+                
+                (idle, hover, sel_idle, sel_hover, disabled) = config.image_buttons[label]
+
+                ui.imagebutton(idle,
+                               hover,
+                               disabled,
+                               hover,
+                               sel_idle,
+                               sel_hover,
+                               disabled,
+                               sel_hover,
+                               clicked=clicked,
+                               style=style.image_button[label],
+                               role=role,
+                               **props)
+                
+                return
+
+            button_style = type + "_button"
+            text_style = type + "_button_text"
+
+            if index is None:
+                index = label
+            
+            button_style = getattr(style, button_style)[index]
+            text_style = getattr(style, text_style)[index]
+            
+            ui.button(style=button_style, clicked=clicked, role=role, **props)
+            ui.text(_(label), style=text_style, **config.button_text_properties.get(label, { }))
+            
+        def _label_factory(label, type, properties={}, **props):
+            """
+            This function is called to create a new label. It can be
+            overridden by the user to change how these labels are created.
+
+            @param label: The label of the box.
+
+            @param type: "prefs" or "yesno". (perhaps more by now.)
+
+            @param properties: This may contain position properties.
+            """
+
+            props.update(properties)
+            props.update(config.label_properties.get(label, { }))
+
+            if label in config.image_labels:
+                ui.image(config.image_labels[label], **props)
+                return
+
+            style = getattr(store.style, type + "_label")[label]
+            
+            ui.text(_(label), style=style, **props)

common/_compat/mainmenu.rpym

@@ -0,0 +1,62 @@
+# Copyright 2004-2008 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init -1170 python hide:
+
+    config.old_names['Quit'] = 'Quit Game'
+
+    # The contents of the main menu.
+    config.main_menu = [
+        ( u"Start Game", "start", 'True'),
+        ( u"Continue Game", _intra_jumps("_load_screen", "main_game_transition"), 'True' ),
+        ( u"Preferences", _intra_jumps("_prefs_screen", "main_game_transition"), 'True' ),
+        ( u"Quit",  ui.jumps("_quit"), 'True' ),
+        ]
+
+    # If not None, this is used to fix the positions of the
+    # things in the main menu.
+    config.main_menu_positions = None
+
+    # Styles used in this file.
+
+# This is the default main menu, which we get if the user hasn't
+# defined his own, or if that function calls this explicitly.        
+label _library_main_menu:
+
+    python hide:
+
+        ui.add(renpy.Keymap(toggle_fullscreen = renpy.toggle_fullscreen))
+
+        ui.window(style='mm_root')
+        ui.null()
+
+        if not config.main_menu_positions:
+            ui.window(style='mm_menu_frame')
+            ui.vbox(style='mm_menu_frame_vbox')
+
+        for i, (text, clicked, enabled) in enumerate(config.main_menu):
+
+            if isinstance(clicked, basestring):
+                clicked = ui.jumpsoutofcontext(clicked)
+
+            if config.main_menu_positions:
+                kwargs = config.main_menu_positions.get(text, { })
+            else:
+                kwargs = { }
+
+            if not eval(enabled):
+                clicked = None
+                disabled = True
+            else:
+                disabled = False
+
+            _button_factory(text, "mm", clicked=clicked, disabled=disabled, properties=kwargs)
+
+        if not config.main_menu_positions:
+            ui.close()
+
+        store._result = ui.interact(suppress_overlay=True,
+                                    suppress_underlay=True,
+                                    mouse="mainmenu")
+
+    jump _main_menu

common/_compat/preferences.rpym

@@ -0,0 +1,607 @@
+# Copyright 2004-2008 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# Copyright 2004-2006 PyTom
+#
+# Please see the LICENSE.txt distributed with Ren'Py for permission to
+# copy and modify.
+
+# This file contains the code to implement the Ren'Py preferences
+# screen.
+
+init python:
+
+    # This is a map from the name of the style that is applied to
+    # a list of preferences that should be placed into a vbox
+    # with that style.
+    config.preferences = { }
+
+    # Ditto, for joystick preferences.
+    config.joystick_preferences = { }
+
+    # Positions for preferences... overrides the above.
+    config.preference_positions = None
+    config.joystick_preference_positions = None
+
+    # This is a map from preference name to that preference
+    # object, that can be used in rearranging preferences.
+    config.all_preferences = { }
+
+    # If true, the preference choices will be arranged in an
+    # hbox.
+    config.hbox_pref_choices = False
+
+    # A list of (readable name, synthetic key) tuples
+    # corresponding to joystick events.
+    config.joystick_keys = [
+        (u'Left', 'joy_left'),
+        (u'Right', 'joy_right'),
+        (u'Up', 'joy_up'),
+        (u'Down', 'joy_down'),
+        (u'Select/Dismiss', 'joy_dismiss'),
+        (u'Rollback', 'joy_rollback'),
+        (u'Hold to Skip', 'joy_holdskip'),
+        (u'Toggle Skip', 'joy_toggleskip'),
+        (u'Hide Text', 'joy_hide'),
+        (u'Menu', 'joy_menu'),
+        ]
+
+    # If True, then we can always get into the joystick
+    # preferences.
+    config.always_has_joystick = False
+
+    
+    def _prefs_screen_run(prefs_map, positions):
+
+
+        _game_nav("prefs")
+
+        if positions is not None:
+            for name, pos in positions.iteritems():
+                ui.vbox(**pos)
+                config.all_preferences[name].render_preference()
+                ui.close()
+
+        else:
+
+            ### prefs_frame default
+            # (window) A window containing all preferences.
+
+            ui.window(style='prefs_frame')
+            ui.fixed()
+
+            for style, prefs in prefs_map.iteritems():
+
+                ui.vbox(style=style)
+                for i in prefs:
+                    i.render_preference()
+                ui.close()
+
+            ui.close()
+
+        _game_interact()
+
+
+    class _Preference(object):
+        """
+        This is a class that's used to represent a multiple-choice
+        preference.
+        """
+
+        def __init__(self, name, field, values, base=_preferences):
+            """
+            @param name: The name of this preference. It will be
+            displayed to the user.
+
+            @param variable: The field on the base object
+            that will be assigned the selected value. This field
+            must exist.
+
+            @param values: A list of value name, value, condition
+            triples. The value name is the name of this value that
+            will be shown to the user. The value is the literal
+            python value that will be assigned if this value is
+            selected. The condition is a condition that will be
+            evaluated to determine if this is a legal value. If no
+            conditions are true, this preference will not be
+            displayed to the user. A condition of None is always
+            considered to be True.
+
+            @param base: The base object on which the variable is
+               read from and set. This defaults to _preferences,
+               the user preferences object.
+            """
+
+            self.name = name
+            self.field = field
+            self.values = values
+            self.base = base
+
+            config.all_preferences[name] = self
+
+        def render_preference(self):
+            values = [ (name, val) for name, val, cond in self.values
+                       if cond is None or renpy.eval(cond) ]
+
+            if not values:
+                return
+
+
+            ui.window(style=style.prefs_pref_frame[self.name])
+            ui.vbox(style=style.prefs_pref_vbox[self.name])
+
+            _label_factory(self.name, "prefs")
+
+            cur = getattr(self.base, self.field)
+
+            ### prefs_hbox default
+            # If config.hbox_pref_choices is True, the style
+            # of the hbox containing the choices.
+
+            if config.hbox_pref_choices:
+                ui.hbox(style=style.prefs_hbox[self.name])
+
+            for name, value in values:
+
+                ### prefs_button menu_button
+                # (window, hover) The style of an unselected preferences
+                # button.
+
+                ### prefs_button_text menu_button_text
+                # (text, hover) The style of the text of an unselected
+                # preferences button.
+
+                def clicked(value=value):
+                    setattr(self.base, self.field, value)
+                    return True
+
+                _button_factory(name, "prefs",
+                                selected=cur==value,
+                                clicked=clicked)
+
+            if config.hbox_pref_choices:
+                ui.close()
+
+            ui.close()
+
+
+    class _VolumePreference(object):
+        """
+        This represents a preference that controls one of the
+        volumes in the system. It is represented as a slider bar,
+        and a button that can be pushed to play a sample sound on
+        a channel.
+        """
+
+        def __init__(self, name, mixer, enable='True', sound='None', channel=0):
+            """
+            @param name: The name of this preference, as shown to the user.
+
+            @param mixer: The mixer this preference controls.
+
+            @param enable: A string giving a python expression. If
+            the expression is evaluates to false, this preference
+            is not shown.
+
+            @param sound: A string that is evaluated to yield
+            another string. The yielded string is expected to give
+            a sound file, which is played as the sample sound. (We
+            apologize for the convolution of this.)
+
+            @param channel: The number of the channel the sample
+            sound is played on.                
+            """
+
+            self.name = name
+            self.mixer = mixer
+            self.enable = enable
+            self.sound = sound
+            self.channel = channel
+
+            config.all_preferences[name] = self
+
+        def render_preference(self):
+
+            if not eval(self.enable):
+                return
+
+            sound = eval(self.sound)
+
+            ui.window(style=style.prefs_pref_frame[self.name])
+            ui.vbox(style=style.prefs_pref_vbox[self.name])
+
+            _label_factory(self.name, "prefs")
+
+            def changed(v):
+
+                _preferences.set_volume(self.mixer, v / 128.0)
+                
+            ui.bar(128,
+                   int(_preferences.get_volume(self.mixer) * 128),
+                   changed=changed,
+                   style=style.prefs_volume_slider[self.name])
+
+            if sound:
+                def clicked():
+                    renpy.sound.play(sound, channel=self.channel)
+
+                _button_factory(u"Test", "soundtest", clicked=clicked, index=self.name)
+
+            ui.close()
+
+    class _SliderPreference(object):
+        """
+        A class that represents a preference that is controlled by a
+        slider.
+        """
+
+        def __init__(self, name, range, get, set, enable='True'):
+            """
+            @param set: The name of this preference, that is shown to the user.
+
+            @param range: An integer giving the maximum value of
+            this slider. The slider goes from 0 to range.
+
+            @param get: A function that's called to get the
+            initial value of the slider. It's called with no
+            arguments, and should return an integet between 0 and
+            range, inclusive.
+
+            @param set: A function that's called when the value of
+            the slider is set by the user. It is called with a
+            single integer, in the range 0 to range, inclusive.
+
+            @param enable: A string giving a python expression. If
+            the expression is evaluates to false, this preference
+            is not shown.
+            """
+
+            self.name = name
+            self.range = range
+            self.get = get
+            self.set = set
+            self.enable = enable
+
+            config.all_preferences[name] = self
+
+        def render_preference(self):
+
+            if not eval(self.enable):
+                return
+
+            ui.window(style=style.prefs_pref_frame[self.name])
+            ui.vbox(style=style.prefs_pref_vbox[self.name])
+
+            _label_factory(self.name, "prefs")
+
+            def changed(v):
+                self.set(v)
+
+            ### prefs_slider bar
+            # (bar) The style that is applied to preference
+            # sliders.
+
+            ui.bar(self.range,
+                   self.get(),
+                   changed=changed,
+                   style=style.prefs_slider[self.name])
+
+            ui.close()
+
+
+    class _PreferenceSpinner(object):
+        """
+        This is a class that's used to represent a preference
+        spinner, which is a preference that can be incremented
+        and decremented, when shown to the user.
+        """
+
+        def __init__(self, name, field, minimum, maximum, delta,
+                     cond = "True", render = lambda x : str(x),
+                     base=_preferences):
+            """
+            @param name: The name of this preference, that is presented
+            to the user.
+
+            @param field: The name of the field on the base object
+            that is updated by this spinner.
+
+            @param minimum: The minimum value that this spinner can set
+            the value to.
+
+            @param maximum: The maximum value that this spinner can set
+            the value to.
+
+            @param delta: The delta by which this spinner is
+            incremented or decremented.
+
+            @param cond: If this condition is not true, this spinner is
+            not shown.
+
+            @param render: This function is called with the value of
+            the field, and is expected to render that value to a
+            string.
+
+            @param base: The base object that this spinner updates
+            the field on. It defaults to _preferences, the preferences
+            object.
+            """
+
+            self.name = name
+            self.field = field
+            self.minimum = minimum
+            self.maximum = maximum
+            self.delta = delta
+            self.cond = cond
+            self.render = render
+            self.base = base
+
+            config.all_preferences[name] = self
+
+        def render_preference(self):
+
+            if not renpy.eval(self.cond):
+                return
+
+            ui.window(style=style.prefs_pref_frame[self.name])
+            ui.vbox(style=style.prefs_pref_vbox[self.name])
+
+            _label_factory(self.name, "prefs")
+
+            cur = getattr(self.base, self.field)
+
+            def minus_clicked():
+                value = cur - self.delta
+                value = max(self.minimum, value)
+                setattr(self.base, self.field, value)
+                return True
+
+            def plus_clicked():
+                value = cur + self.delta
+                value = min(self.maximum, value)
+                setattr(self.base, self.field, value)
+                return True
+
+            ui.hbox(style=style.prefs_spinner[self.name])
+            _button_factory("-", "prefs_spinner", clicked=minus_clicked)
+            _label_factory(self.render(cur), "prefs_spinner")
+            _button_factory("+", "prefs_spinner", clicked=plus_clicked)
+            ui.close()
+
+            ui.close()
+
+    def _joystick_select_binding():
+
+        for label, key in config.joystick_keys:
+
+            def my_clicked(label=label, key=key):
+                return (label, key)
+
+            _button_factory(_(label) + " - " + _(_preferences.joymap.get(key, u"Not Assigned")), "prefs_js", clicked=my_clicked, index=label)
+        
+
+    def _joystick_get_binding():
+        ui.add(renpy.display.joystick.JoyBehavior())
+        ui.saybehavior()
+
+    def _joystick_take_binding(binding, key):
+
+        if not isinstance(binding, basestring):
+            if key in _preferences.joymap:
+                del _preferences.joymap[key]
+        else:
+            _preferences.joymap[key] = binding
+
+        
+            
+    class _JoystickPreference(object):
+
+        def __init__(self, name):
+            self.name = name
+            config.all_preferences[name] = self
+
+            
+        def render_preference(self):
+
+            def set_binding(label, key):
+                _game_nav(None)
+
+                ui.window(style='js_frame')
+                ui.vbox(style='js_frame_vbox')
+                _label_factory(_(u"Joystick Mapping") + " - " + _(label), "js_function")
+                _label_factory(u'Move the joystick or press a joystick button to create the mapping. Click the mouse to remove the mapping.', 'js_prompt')
+                ui.close()
+
+                _joystick_get_binding()
+                binding = _game_interact()
+                _joystick_take_binding(binding, key)
+                
+                return True
+                
+
+            ui.window(style='prefs_js_frame')
+            ui.vbox(style='prefs_js_vbox')
+            _label_factory(self.name, 'prefs')
+
+            for label, key in config.joystick_keys:
+
+                def clicked(label=label, key=key):
+                    return renpy.invoke_in_new_context(set_binding, label, key)
+
+                _button_factory(_(label) + " - " + _(_preferences.joymap.get(key, u"Not Assigned")), "prefs_js", clicked=clicked, index=label)
+            
+            ui.close()
+            
+
+    class _JumpPreference(object):
+
+        def __init__(self, name, target, condition="True"):
+            self.name = name
+            self.target = target
+            self.condition = condition
+
+            config.all_preferences[name] = self
+
+        def render_preference(self):
+
+            ui.window(style=style.prefs_jump[self.name])
+
+            if eval(self.condition):
+                clicked=ui.jumps(self.target)
+            else:
+                clicked=None
+
+            _button_factory(self.name, 'prefs_jump', clicked=clicked)
+
+    def _remove_preference(name):
+        """
+        Removes the preference with the given name from the
+        preferences menu.
+        """
+
+        pref = config.all_preferences.get(name, None)
+        if not pref:
+            return
+
+        for k, v in config.preferences.iteritems():
+            if pref in v:
+                v.remove(pref)
+            
+init python hide:
+
+    # Enablers for some preferences.
+    config.has_music = True
+    config.has_sound = True
+    config.sample_sound = None
+    config.has_transitions = True
+    config.has_cps = True
+    config.has_afm = True
+    config.has_skipping = True
+    config.has_skip_after_choice = True
+
+
+    # Left
+
+    pl1 = _Preference(u'Display', 'fullscreen', [
+        (u'Window', False, None),
+        (u'Fullscreen', True, None),
+        ])
+
+    pl2 = _Preference(u'Transitions', 'transitions', [
+        (u'All', 2, 'config.has_transitions'),
+        (u'Some', 1, 'config.has_transitions and default_transition'),
+        (u'None', 0, 'config.has_transitions'),
+        ])
+
+    # Center
+
+    pc1 = _Preference(u'Skip', 'skip_unseen', [
+        (u'Seen Messages', False, 'config.allow_skipping and config.has_skipping'),
+        (u'All Messages', True, 'config.allow_skipping and config.has_skipping'),
+        ])
+
+    config.old_names['Skip'] = 'TAB and CTRL Skip'
+    config.all_preferences['TAB and CTRL Skip'] = pc1
+
+
+    pc2= _Preference(u'After Choices', 'skip_after_choices', [
+        (u'Stop Skipping', False, 'config.allow_skipping and config.has_skip_after_choice'),
+        (u'Keep Skipping', True, 'config.allow_skipping and config.has_skip_after_choice'),
+        ])
+
+    config.old_names['Keep Skipping'] = 'Continue Skipping' 
+
+    def cps_get():
+        cps = _preferences.text_cps
+        if cps == 0:
+            cps = 150
+        else:
+            cps -= 1
+        return cps
+
+    def cps_set(cps):
+        cps += 1
+        if cps == 151:
+            cps = 0
+        _preferences.text_cps = cps
+
+
+    pc3 = _SliderPreference(u'Text Speed', 150, cps_get, cps_set,
+                            'config.has_cps')
+
+
+    def afm_get():
+        afm = _preferences.afm_time
+        if afm == 0:
+            afm = 40
+        else:
+            afm -= 1
+        return afm
+
+    def afm_set(afm):
+        afm += 1
+        if afm == 41:
+            afm = 0
+        _preferences.afm_time = afm
+
+    pc4 = _SliderPreference(u'Auto-Forward Time', 40, afm_get, afm_set,
+                            'config.has_afm')
+
+    # Right
+
+    pr1 = _VolumePreference(u"Music Volume", 'music', 'config.has_music')
+    pr2 = _VolumePreference(u"Sound Volume", 'sfx', 'config.has_sound', 'config.sample_sound')
+
+    _JumpPreference(u'Joystick...', '_joystick_screen', 'renpy.display.joystick.enabled or config.always_has_joystick')
+
+    _JoystickPreference(u'Joystick Configuration')
+
+    config.preferences['prefs_left'] = [
+        config.all_preferences[u'Display'],
+        config.all_preferences[u'Transitions'],
+        config.all_preferences[u'Joystick...'],
+        ]
+
+    config.preferences['prefs_center'] = [
+        config.all_preferences[u'Skip'],
+        config.all_preferences[u'After Choices'],
+        config.all_preferences[u'Text Speed'],
+        config.all_preferences[u'Auto-Forward Time'],
+        ]
+
+    config.preferences['prefs_right'] = [
+        config.all_preferences[u'Music Volume'],
+        config.all_preferences[u'Sound Volume'],
+        ]
+
+    config.joystick_preferences['prefs_joystick'] = [
+        config.all_preferences[u'Joystick Configuration'],
+        ]
+
+    config.sample_voice = None
+
+    vp = _VolumePreference(u'Voice Volume',
+                           'voice',
+                           'config.has_voice',
+                           'config.sample_voice',
+                           2)
+
+    config.preferences['prefs_right'].insert(1, vp)
+
+label _prefs_screen:
+
+    $ _prefs_screen_run(config.preferences, config.preference_positions)
+    
+    jump _prefs_screen
+    
+label _joystick_screen:    
+        
+    $ _prefs_screen_run(config.joystick_preferences, config.joystick_preference_positions)
+
+    jump _joystick_screen
+
+            
+                        
+
+                         
+                         

common/_compat/styles.rpym

@@ -0,0 +1,357 @@
+# Copyright 2004-2008 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python hide:
+
+    style.menu_button = Style(style.button, heavy=True, help='Buttons that are part of the main or game menus.')
+    style.menu_button_text = Style(style.button_text, heavy=True, help='The label of buttons that are part of the main or game menus.')
+    
+    style.thin_hbox = Style(style.hbox, heavy=True, help='A hbox with a small amount of spacing.')
+    style.thick_hbox = Style(style.hbox, heavy=True, help='A hbox with a large amount of spacing.')
+    style.thin_vbox = Style(style.vbox, heavy=True, help='A vbox with a small amount of spacing.')
+    style.thick_vbox = Style(style.vbox, heavy=True, help='A vbox with a large amount of spacing.')
+
+    style.mm_menu_frame = Style(style.default, heavy=True, help='The frame containing the main menu.')
+    style.mm_menu_frame_vbox = Style(style.thin_vbox, heavy=True, help='The vbox containing the main menu.')
+    style.mm_button = Style(style.menu_button, heavy=True, help='A main menu button.')
+    style.mm_button_text = Style(style.menu_button_text, heavy=True, help='A main menu button label.')
+    style.default.drop_shadow = (1, 1)
+
+    style.gm_nav_frame = Style(style.default, heavy=True, help='The frame containing the navigation buttons.')
+    style.gm_nav_vbox = Style(style.thin_vbox, heavy=True, help='The vbox containing the navigation buttons.')
+    style.gm_nav_button = Style(style.menu_button, heavy=True, help='A navigation button.')
+    style.gm_nav_button_text = Style(style.menu_button_text, heavy=True, help='A navigation button label.')
+
+    style.file_picker_entry = Style(style.menu_button, heavy=True, help='A button you click to save or load a file.')
+    style.file_picker_entry_box = Style(style.thin_hbox, heavy=True, help='The box inside that button.')
+    style.file_picker_text = Style(style.default, heavy=True, help='Base style for text inside a file picker entry.')
+    style.file_picker_new = Style(style.file_picker_text, heavy=True, help='The number of the newest file.')
+    style.file_picker_old = Style(style.file_picker_text, heavy=True, help='The number of non-newest files.')
+    style.file_picker_extra_info = Style(style.file_picker_text, heavy=True, help='Extra text (the date and save info) of a file.')
+    style.file_picker_empty_slot = Style(style.file_picker_text, heavy=True, help='The style of "Empty Slot" text.')
+    style.file_picker_frame = Style(style.default, heavy=True, help='The frame containing the file picker.')
+    style.file_picker_frame_vbox = Style(style.thin_vbox, heavy=True, help='The box containing file picker navigation and the file picker grid.')
+    style.file_picker_navbox = Style(style.thick_hbox, heavy=True, help='The box containing the file picker navigation buttons.')
+    style.file_picker_nav_button = Style(style.menu_button, heavy=True, help='A file picker navigation button.')
+    style.file_picker_nav_button_text = Style(style.menu_button_text, heavy=True, help='A file picker navigation button label.')
+    style.file_picker_grid = Style(style.default, heavy=True, help='The grid containing the entries in the file picker.')
+
+    style.yesno_frame = Style(style.default, heavy=True, help='The frame containing the yes/no dialog.')
+    style.yesno_frame_vbox = Style(style.thick_vbox, heavy=True, help='Separates the label from the buttons in a yes/no dialog.')
+    style.yesno_label = Style(style.default, heavy=True, help='The label of a yes/no dialog.')
+    style.yesno_button_hbox = Style(style.thick_hbox, heavy=True, help="The box containing the Yes and No buttons.")
+    style.yesno_button = Style(style.menu_button, heavy=True, help='A Yes/No button.')
+    style.yesno_button_text = Style(style.menu_button_text, heavy=True, help='A Yes/No button label.')
+
+
+    style.prefs_frame = Style(style.default, heavy=True, help='')
+    style.prefs_pref_frame = Style(style.default, heavy=True, help='')
+    style.prefs_pref_vbox = Style(style.thin_vbox, heavy=True, help='')
+    style.prefs_label = Style(style.default, heavy=True, help='')
+    style.prefs_hbox = Style(style.default, heavy=True, help='')
+    style.prefs_button = Style(style.menu_button, heavy=True, help='')
+    style.prefs_button_text = Style(style.menu_button_text, heavy=True, help='')
+    style.soundtest_button = Style(style.prefs_button, heavy=True, help='')
+    style.soundtest_button_text = Style(style.prefs_button_text, heavy=True, help='')
+    style.prefs_slider = Style(style.bar, heavy=True, help='')
+    style.prefs_volume_slider = Style(style.prefs_slider, heavy=True, help='')
+    style.prefs_spinner = Style(style.default, heavy=True, help='')
+    style.prefs_spinner_label = Style(style.prefs_label, heavy=True, help='')
+    style.prefs_spinner_button = Style(style.prefs_button, heavy=True, help='')
+    style.prefs_spinner_button_text = Style(style.prefs_button_text, heavy=True, help='')
+    style.prefs_js_frame = Style(style.prefs_pref_frame, heavy=True, help='')
+    style.prefs_js_vbox = Style(style.prefs_pref_vbox, heavy=True, help='')
+    style.prefs_js_button = Style(style.prefs_button, heavy=True, help='')
+    style.prefs_js_button_text = Style(style.prefs_button_text, heavy=True, help='')
+    style.js_frame = Style(style.prefs_frame, heavy=True, help='')
+    style.js_frame_vbox = Style(style.thick_vbox, heavy=True, help='')
+    style.js_function_label = Style(style.prefs_label, heavy=True, help='')
+    style.js_prompt_label = Style(style.prefs_label, heavy=True, help='')
+    style.prefs_jump = Style(style.prefs_pref_frame, heavy=True, help='')
+    style.prefs_jump_button = Style(style.prefs_button, heavy=True, help='')
+    style.prefs_jump_button_text = Style(style.prefs_button_text, heavy=True, help='')
+    style.prefs_column = Style(style.default, heavy=True, help='')
+    style.prefs_left = Style(style.prefs_column, heavy=True, help='')
+    style.prefs_center = Style(style.prefs_column, heavy=True, help='')
+    style.prefs_right = Style(style.prefs_column, heavy=True, help='')
+    style.prefs_joystick = Style(style.prefs_center, heavy=True, help='')
+
+    style.thin_hbox.spacing = 3
+    style.thick_hbox.spacing = 30
+    style.thin_vbox.spacing = 0
+    style.thick_vbox.spacing = 30
+
+    dark_cyan = (0, 192, 255, 255)
+    bright_cyan = (0, 255, 255, 255)
+    dark_red = (255, 128, 128, 255)
+    bright_red = (255, 64, 64, 255)
+    green = (0, 128, 0, 255)
+
+    # Frames.
+    style.frame.background = Solid((0, 0, 128, 128))
+    style.frame.xpadding = 10
+    style.frame.ypadding = 5
+    style.frame.xmargin = 10
+    style.frame.ymargin = 5
+
+
+    ######################################################################
+    # Buttons.
+
+    style.button_text.color = dark_cyan
+    style.button_text.hover_color = bright_cyan
+    style.button_text.insensitive_color = (192, 192, 192, 255)
+    style.button_text.size = 24
+    style.button_text.drop_shadow = (2, 2)        
+
+    style.button_text.selected_color = dark_red
+    style.button_text.selected_hover_color = bright_red
+
+    style.button_text.xpos = 0.5
+    style.button_text.xanchor = 0.5
+
+    style.menu_button.xpos = 0.5
+    style.menu_button.xanchor = 0.5
+
+
+    ######################################################################
+    # Bar.
+
+    style.bar.ymaximum = 22
+
+    style.bar.left_bar = Solid(bright_cyan)
+    style.bar.right_bar = Solid((0, 0, 0, 128))
+    style.bar.bottom_bar = Solid(bright_cyan)
+    style.bar.top_bar = Solid((0, 0, 0, 128))
+    style.bar.left_gutter = 0
+    style.bar.right_gutter = 0
+    style.bar.thumb = None
+    style.bar.thumb_offset = 0
+    style.bar.thumb_shadow = None
+
+    style.vbar.xmaximum = 22
+
+    style.vbar.left_bar = Solid(bright_cyan)
+    style.vbar.right_bar = Solid((0, 0, 0, 128))
+    style.vbar.bottom_bar = Solid(bright_cyan)
+    style.vbar.top_bar = Solid((0, 0, 0, 128))
+    style.vbar.left_gutter = 0
+    style.vbar.right_gutter = 0
+    style.vbar.bottom_gutter = 0
+    style.vbar.top_gutter = 0
+    style.vbar.thumb = None
+    style.vbar.thumb_offset = 0
+    style.vbar.thumb_shadow = None
+
+    style.vscrollbar.set_parent(style.vbar)
+    style.scrollbar.set_parent(style.bar)
+    
+    style.vscrollbar.bottom_bar = Solid((0, 0, 0, 128))        
+    style.vscrollbar.top_bar = Solid(bright_cyan) 
+
+    style.slider.ymaximum = 1
+    style.vslider.xmaximum = 1
+    
+    ######################################################################
+    # Main menu.
+
+    style.mm_menu_frame.xpos = 0.9
+    style.mm_menu_frame.xanchor = 1.0
+    style.mm_menu_frame.ypos = 0.9
+    style.mm_menu_frame.yanchor = 1.0
+
+
+    ######################################################################
+    # Game menu common.
+
+    style.gm_nav_frame.xpos = 0.95
+    style.gm_nav_frame.xanchor = 1.0
+    style.gm_nav_frame.ypos = 0.95
+    style.gm_nav_frame.yanchor = 1.0
+
+
+    ##############################################################################
+    # File picker.
+
+    style.file_picker_frame.xpos = 0
+    style.file_picker_frame.xanchor = 0.0
+    style.file_picker_frame.ypos = 0
+    style.file_picker_frame.yanchor = 0.0
+    style.file_picker_frame.xpadding = 5
+
+    style.file_picker_navbox.xpos = 10
+
+    style.file_picker_grid.xfill = True
+
+    style.file_picker_entry.xpadding = 5
+    style.file_picker_entry.ypadding = 2
+    style.file_picker_entry.xmargin = 5
+    style.file_picker_entry.xfill = True
+    style.file_picker_entry.ymargin = 2        
+    style.file_picker_entry.background = Solid((255, 255, 255, 255))
+    style.file_picker_entry.hover_background = Solid((255, 255, 192, 255))
+
+    style.file_picker_text.size = 16
+    style.file_picker_text.color = dark_cyan
+    style.file_picker_text.hover_color = bright_cyan
+
+    style.file_picker_new.hover_color = bright_red
+    style.file_picker_new.idle_color = dark_red
+
+    style.file_picker_new.minwidth = 40
+    style.file_picker_old.minwidth = 40
+
+    style.file_picker_new.text_align = 1.0
+    style.file_picker_old.text_align = 1.0
+
+
+    ######################################################################
+    # Yes/No Dialog
+
+    style.yesno_label.color = green
+    style.yesno_label.textalign = 0.5
+    style.yesno_label.xpos = 0.5
+    style.yesno_label.xanchor = 0.5
+
+    style.yesno_frame.xfill = True
+    style.yesno_frame.yminimum = 0.5
+    style.yesno_frame.xmargin = .1
+
+    style.yesno_frame_vbox.xpos = 0.5
+    style.yesno_frame_vbox.xanchor = 0.5
+    style.yesno_frame_vbox.ypos = 0.5
+    style.yesno_frame_vbox.yanchor = 0.5
+
+    style.yesno_button_hbox.xalign = 0.5
+    style.yesno_button_hbox.spacing = 100
+    
+    ##############################################################################
+    # Preferences.
+
+
+    style.prefs_pref_frame.xpos = 0.5
+    style.prefs_pref_frame.xanchor = 0.5
+    style.prefs_pref_frame.bottom_margin = 10
+
+    style.prefs_label.xpos = 0.5
+    style.prefs_label.xanchor = 0.5
+    style.prefs_label.color = green
+
+    style.prefs_slider.xmaximum=200
+    style.prefs_slider.ymaximum=22
+    style.prefs_slider.xpos = 0.5
+    style.prefs_slider.xanchor = 0.5
+
+    style.prefs_hbox.xpos = 0.5
+    style.prefs_hbox.xanchor = 0.5
+
+    style.prefs_button.xpos = 0.5
+    style.prefs_button.xanchor = 0.5
+
+    style.prefs_button.selected_xpos = 0.5
+    style.prefs_button.selected_xanchor = 0.5
+
+    style.prefs_frame.xfill=True
+    style.prefs_frame.ypadding = 0.05
+
+    style.prefs_column.spacing = 6
+
+    style.prefs_left.xanchor = 0.5
+    style.prefs_left.xpos = 1.0 / 6.0
+
+    style.prefs_center.xanchor = 0.5
+    style.prefs_center.xpos = 3.0 / 6.0
+
+    style.prefs_right.xanchor = 0.5
+    style.prefs_right.xpos = 5.0 / 6.0
+
+    style.prefs_spinner.xpos = 0.5
+    style.prefs_spinner.xanchor = 0.5
+
+    style.prefs_spinner_label.minwidth = 100
+    style.prefs_spinner_label.textalign = 0.5
+
+    style.prefs_js_button_text.size = 18
+    style.prefs_js_button_text.drop_shadow = (1, 1)
+
+    style.js_function_label.textalign = 0.5
+    style.js_prompt_label.textalign = 0.5
+
+    style.js_frame.xfill = True
+    style.js_frame.yminimum = 0.5
+    style.js_frame.xmargin = .1
+
+    style.js_frame_vbox.xpos = 0.5
+    style.js_frame_vbox.xanchor = 0.5
+    style.js_frame_vbox.ypos = 0.5
+    style.js_frame_vbox.yanchor = 0.5
+
+    style.soundtest_button.activate_sound = None
+
+    style.window.background = Solid((0, 0, 128, 128))
+    style.window.xpadding = 10
+    style.window.ypadding = 5
+    style.window.xmargin = 10
+    style.window.ymargin = 5
+    style.window.xfill = True
+    style.window.yfill = False
+    style.window.xminimum = 0 # Includes margins and padding.
+    style.window.yminimum = 150 # Includes margins and padding.
+
+
+    
+    ######################################################################
+    # Compatibility names for renamed styles.
+    style.file_picker_window_vbox = style.file_picker_frame_vbox
+    style.prefs_window = style.prefs_frame
+    style.mm_root_window = style.mm_root
+    style.file_picker_window = style.file_picker_frame
+    style.prefs_pref = style.prefs_pref_frame
+    style.gm_root_window = style.gm_root
+    style.yesno_window_vbox = style.yesno_frame_vbox
+    style.joyprompt_label = style.js_prompt_label
+    style.gm_nav_window = style.gm_nav_frame
+    style.joy_window = style.js_frame
+    style.mm_menu_window = style.mm_menu_frame
+    style.error_window = style.error_root
+    style.joyfunc_label = style.js_function_label
+    style.joy_vbox = style.js_frame_vbox
+    style.yesno_window = style.yesno_frame
+    style.mm_menu_window_vbox = style.mm_menu_frame_vbox
+    style.menu_choice_button_text = style.menu_choice
+    style.menu_choice_chosen_button_text = style.menu_choice_chosen
+
+    store._selected_compat = [ ]
+
+    class _SelectedCompat(object):
+
+        def __init__(self, target):
+            self.__dict__["target"] = target
+            self.__dict__["property_updates"] = [ ]
+
+            store._selected_compat.append(self)
+
+        def __setattr__(self, k, v):
+            self.property_updates.append((k, v))
+
+        def apply(self):
+            target = getattr(style, self.target)
+            for k, v in self.property_updates:
+                setattr(target, "selected_" + k, v)
+
+        def clear(self):
+            self.__dict__["property_updates"] = [ ]
+
+
+    style.selected_button = _SelectedCompat('button')
+    style.selected_button_text = _SelectedCompat('button_text')
+    style.gm_nav_selected_button = _SelectedCompat('gm_nav_button')
+    style.gm_nav_selected_button_text = _SelectedCompat('gm_nav_button_text')
+    style.prefs_selected_button = _SelectedCompat('prefs_button')
+    style.prefs_selected_button_text = _SelectedCompat('prefs_button_text')
+    
+    def apply_selected_compat():
+        for scs in _selected_compat:
+            scs.apply()
+
+    layout.compat_funcs.append(apply_selected_compat)

common/_compat/themes.rpym

@@ -0,0 +1,503 @@
+# Copyright 2004-2008 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# Copyright 2004-2007 PyTom
+#
+# Please see the LICENSE.txt distributed with Ren'Py for permission to
+# copy and modify.
+
+init -1100:
+    python:
+
+        theme = object()
+
+        def RoundRect(color, small=False):
+            """
+            Creates a roundrect displayable. Size should be one of
+            6 or 12, while color is the color of the roundrect.
+            """
+
+            if small:
+                size = 6
+            else:
+                if config.screen_width <= 640:
+                    size = 6
+                else:
+                    size = 12
+
+            return Frame(theme.OneOrTwoColor("_roundrect/rr%dg.png" % size, color), size, size)
+                            
+        def _display_button_menu(menuitems):
+
+            narration = [ s for s, i in menuitems if i is None and s ]
+            menuitems = [ (s, i) for s, i in menuitems if i is not None or not s ]
+
+            if narration:
+                renpy.say(None, "\n".join(narration), interact=False)
+
+            return renpy.display_menu(menuitems)
+
+        def _button_menu():
+
+            store.menu = _display_button_menu
+
+            style.menu.clear()
+            style.menu.box_spacing = 2
+
+            style.menu_window.clear()
+            style.menu_window.take(style.default)
+            style.menu_window.xpos = 0.5
+            style.menu_window.xanchor = 0.5
+            style.menu_window.ypos = 0.5
+            style.menu_window.yanchor = 0.5
+
+            style.menu_choice.clear()
+            style.menu_choice.take(style.button_text)
+
+            style.menu_choice_button.clear()
+            style.menu_choice_button.take(style.button)
+
+            style.menu_choice_chosen.clear()
+            style.menu_choice_chosen_button.clear()
+
+            style.menu_choice_button.xminimum = int(config.screen_width * 0.75)
+            style.menu_choice_button.xmaximum = int(config.screen_width * 0.75)
+
+
+        theme.button_menu = _button_menu
+            
+    python hide:
+
+        def OneOrTwoColor(image, color):
+            if len(color) == 2:
+                return im.Twocolor(image, color[0], color[1])
+            else:
+                return im.Twocolor(image, color, color)
+            
+        theme.OneOrTwoColor = OneOrTwoColor
+        
+
+        def theme_roundrect(
+            widget = (0, 60, 120, 255),
+            widget_hover = (0, 80, 160, 255),
+            widget_text = (200, 225, 255, 255),
+            widget_selected = (255, 255, 200, 255),
+            disabled = (64, 64, 64, 255),
+            disabled_text = (200, 200, 200, 255),
+            label = (255, 255, 255, 255),
+            frame = (100, 150, 200, 255),
+            window = (0, 0, 0, 192),
+            mm_root = Solid((220, 235, 255, 255)),
+            gm_root = Solid((220, 235, 255, 255)),
+            centered = False,
+            button_menu = True,
+            launcher = False,
+            rounded_window = True,
+            less_rounded = False,
+            ):
+
+            """This enables the use of the roundrect theme. By
+               default, this theme styles the game in a blue color
+               scheme. However, by supplying one or more of the
+               parameters given below, the color scheme can be
+               changed.
+
+               @param widget: The background color of non-focued
+               buttons and sliders.
+
+               @param widget_hover: The background color of focused
+               buttons and sliders.
+
+               @param widget_text: The text color of non-selected buttons.
+
+               @param widget_selected: The text color of selected buttons.
+
+               @param disabled: The background color of disabled buttons.
+
+               @param disabled_text: The text color of disabled buttons.
+
+               @param label: The text color of non-selected labels.
+
+               @param frame: The background color of frames.
+
+               @param mm_root: A displayable (such as
+               an Image or Solid) that will be used as
+               the background for the main menu.
+
+               @param gm_root: A displayable (such as
+               an Image or Solid) that will be used as
+               the background for the game menu.
+
+               @param centered: If True, the buttons and sliders will
+               be centered in the frames or windows that contain
+               them. If False, the default, they will be pushed to the
+               right side.
+               """
+
+            if config.screen_width <= 640:
+                size = 18
+                small = 12
+
+                big = False
+
+                spacing = 0
+                pref_spacing = 5
+                title_spacing = 6
+
+                frame_width = 200
+                widget_width = 160
+
+                config.thumbnail_width = 60
+                config.thumbnail_height = 45
+
+                config.file_page_cols = 2
+                config.file_page_rows = 4
+                # style.file_picker_frame.xmaximum = 450
+
+                prefcols = [ 110, 320, 530 ]
+
+                nav_xpos = 530
+                    
+            else:
+
+                size = 22
+                small = 16
+
+                big = True
+
+                spacing = 0
+                pref_spacing = 10
+                title_spacing = 12
+
+                frame_width = 250
+                widget_width = 200
+
+                prefcols = [ 137, 400, 663 ]
+
+                nav_xpos = 663
+                
+            rrslider_empty = "_roundrect/rrslider_empty.png"
+            rrslider_full = "_roundrect/rrslider_full.png"
+            rrslider_thumb = "_roundrect/rrslider_thumb.png"
+
+            rrslider_radius = 6
+            rrslider_height = 24
+
+            rrvslider_empty = "_roundrect/rrvslider_empty.png"
+            rrvslider_full = "_roundrect/rrvslider_full.png"
+            rrvslider_thumb = "_roundrect/rrvslider_thumb.png"
+
+            rrscrollbar = "_roundrect/rrscrollbar.png"
+            rrscrollbar_thumb = "_roundrect/rrscrollbar_thumb.png"
+            rrvscrollbar = "_roundrect/rrvscrollbar.png"
+            rrvscrollbar_thumb = "_roundrect/rrvscrollbar_thumb.png"
+            
+            rrvslider_radius = 6
+            rrvslider_width = 24
+
+
+            def rrframe(sty):
+                sty.background = RoundRect(frame, less_rounded)
+                sty.xpadding = 6
+                sty.ypadding = 6
+
+            if big and not less_rounded:
+                store._roundrect_radius = 12
+            else:
+                store._roundrect_radius = 6
+
+            style.button.clear()
+            style.button.background = RoundRect(widget, less_rounded)
+            style.button.hover_background = RoundRect(widget_hover, less_rounded)
+            style.button.xminimum = widget_width
+            style.button.ypadding = 1
+            style.button.xpadding = _roundrect_radius
+            style.button.xmargin = 1
+            style.button.ymargin = 1
+
+            style.button_text.clear()
+            style.button_text.drop_shadow = None
+            style.button_text.color = widget_text
+            style.button_text.size = size
+            style.button_text.xpos = 0.5
+            style.button_text.xanchor = 0.5
+            style.button_text.ypos = 0.5
+            style.button_text.yanchor = 0.5
+            style.button_text.textalign = 0.5 
+
+            style.button.insensitive_background = RoundRect(disabled, less_rounded)
+            style.button_text.insensitive_color = disabled_text
+
+            style.button_text.selected_color = widget_selected 
+
+            style.menu_button.clear()
+            
+            style.mm_root.background = mm_root
+            style.gm_root.background = gm_root
+            
+            style.mm_menu_frame_vbox.box_spacing = spacing
+            rrframe(style.mm_menu_frame)
+            style.mm_menu_frame.xpos = nav_xpos
+            style.mm_menu_frame.xanchor = 0.5
+
+            style.gm_nav_vbox.box_spacing = spacing
+            rrframe(style.gm_nav_frame)
+            style.gm_nav_frame.xpos = nav_xpos
+            style.gm_nav_frame.xanchor = 0.5
+
+            
+            rrframe(style.prefs_pref_frame)
+            del style.prefs_pref_frame.bottom_margin
+            style.prefs_pref_frame.xfill = True
+
+            style.prefs_pref_vbox.box_spacing = spacing
+            style.prefs_pref_vbox.box_first_spacing = title_spacing
+            style.prefs_pref_vbox.xfill = True
+
+            style.prefs_frame.ypadding = pref_spacing
+
+            rrframe(style.prefs_column)
+            style.prefs_column.box_spacing = pref_spacing
+            style.prefs_column.xmaximum = frame_width
+
+            style.prefs_left.xpos = prefcols[0]
+            style.prefs_center.xpos = prefcols[1]
+            style.prefs_right.xpos = prefcols[2]
+
+            style.prefs_label.color = label
+            style.prefs_label.size = size
+            style.prefs_label.drop_shadow = None
+            style.prefs_label.xpos = 0
+            style.prefs_label.xanchor = 0
+
+            if centered:
+                style.prefs_button.xpos = 0.5
+                style.prefs_button.xanchor = 0.5
+            else:
+                style.prefs_button.xpos = 1.0
+                style.prefs_button.xanchor = 1.0
+
+
+                
+            style.bar.ymaximum = rrslider_height
+            style.bar.left_gutter = rrslider_radius
+            style.bar.right_gutter = rrslider_radius
+            style.bar.thumb_offset = -rrslider_radius
+
+            style.bar.left_bar = Frame(theme.OneOrTwoColor(rrslider_full, widget), rrslider_radius * 2, 0)
+            style.bar.right_bar = Frame(theme.OneOrTwoColor(rrslider_empty, widget), rrslider_radius * 2, 0)
+            style.bar.thumb = theme.OneOrTwoColor(rrslider_thumb, widget)
+
+            style.bar.hover_left_bar = Frame(theme.OneOrTwoColor(rrslider_full, widget_hover), rrslider_radius * 2, 0)
+            style.bar.hover_right_bar = Frame(theme.OneOrTwoColor(rrslider_empty, widget_hover), rrslider_radius * 2, 0)
+            style.bar.hover_thumb = theme.OneOrTwoColor(rrslider_thumb, widget_hover)
+
+            style.scrollbar.clear()
+            style.scrollbar.left_bar = Frame(theme.OneOrTwoColor(rrscrollbar, widget), 6, 0)
+            style.scrollbar.right_bar = Frame(theme.OneOrTwoColor(rrscrollbar, widget), 6, 0)
+            style.scrollbar.hover_left_bar = Frame(theme.OneOrTwoColor(rrscrollbar, widget_hover), 6, 0)
+            style.scrollbar.hover_right_bar = Frame(theme.OneOrTwoColor(rrscrollbar, widget_hover), 6, 0)
+            style.scrollbar.thumb = Frame(theme.OneOrTwoColor(rrscrollbar_thumb, widget), 6, 0) 
+            style.scrollbar.hover_thumb = Frame(theme.OneOrTwoColor(rrscrollbar_thumb, widget_hover), 6, 0) 
+            style.scrollbar.left_gutter = 6
+            style.scrollbar.right_gutter = 6
+            style.scrollbar.ymaximum = 12
+            style.scrollbar.thumb_offset = 6
+            
+            style.vbar.xmaximum = rrvslider_width
+            style.vbar.top_gutter = rrvslider_radius
+            style.vbar.bottom_gutter = rrvslider_radius
+            style.vbar.thumb_offset = -rrvslider_radius
+
+            style.vbar.bottom_bar = Frame(theme.OneOrTwoColor(rrvslider_full, widget), 0, rrvslider_radius * 2)
+            style.vbar.top_bar = Frame(theme.OneOrTwoColor(rrvslider_empty, widget), 0, rrvslider_radius * 2)
+            style.vbar.thumb = theme.OneOrTwoColor(rrvslider_thumb, widget)
+
+            style.vbar.hover_bottom_bar = Frame(theme.OneOrTwoColor(rrvslider_full, widget_hover), 0, rrvslider_radius * 2)
+            style.vbar.hover_top_bar = Frame(theme.OneOrTwoColor(rrvslider_empty, widget_hover), 0, rrvslider_radius * 2)
+            style.vbar.hover_thumb = theme.OneOrTwoColor(rrvslider_thumb, widget_hover)
+
+            style.vscrollbar.clear()
+            style.vscrollbar.bar_invert = True
+            style.vscrollbar.top_bar = Frame(theme.OneOrTwoColor(rrvscrollbar, widget), 0, 6)
+            style.vscrollbar.bottom_bar = Frame(theme.OneOrTwoColor(rrvscrollbar, widget), 0, 6)
+            style.vscrollbar.hover_top_bar = Frame(theme.OneOrTwoColor(rrvscrollbar, widget_hover), 0, 6)
+            style.vscrollbar.hover_bottom_bar = Frame(theme.OneOrTwoColor(rrvscrollbar, widget_hover), 0, 6)
+            style.vscrollbar.thumb = Frame(theme.OneOrTwoColor(rrvscrollbar_thumb, widget), 0, 6) 
+            style.vscrollbar.hover_thumb = Frame(theme.OneOrTwoColor(rrvscrollbar_thumb, widget_hover), 0, 6) 
+            style.vscrollbar.top_gutter = 6
+            style.vscrollbar.bottom_gutter = 6
+            style.vscrollbar.xmaximum = 12
+            style.vscrollbar.thumb_offset = 6
+            
+            style.prefs_slider.xmaximum=widget_width
+            del style.prefs_slider.ymaximum
+
+            if centered:
+                style.prefs_slider.xpos = 0.5
+                style.prefs_slider.xanchor = 0.5
+            else:                
+                style.prefs_slider.xpos = 1.0
+                style.prefs_slider.xanchor = 1.0
+
+            style.soundtest_button.xminimum = 0
+
+            # Joystick
+
+            style.prefs_joystick.xmaximum = 600
+            style.prefs_joystick.xpos = 0.5
+            style.prefs_joystick.xanchor = 0.5
+            style.prefs_js_button.background = RoundRect(widget, True)
+            style.prefs_js_button.hover_background = RoundRect(widget_hover, True)
+            style.prefs_js_button_text.drop_shadow = None
+            style.prefs_js_button_text.size = small
+            style.prefs_js_button.xminimum = 450
+
+            rrframe(style.js_frame)
+            del style.js_frame.yminimum
+            style.js_frame.ypadding = .05
+            style.js_frame.xpadding = rrslider_radius
+            style.js_frame.xmargin = .05
+            style.js_frame.ypos = .1
+            style.js_frame.yanchor = 0
+
+            style.js_function_label.xpos = 0.5
+            style.js_function_label.xanchor = 0.5
+
+            style.js_prompt_label.xpos = 0.5
+            style.js_prompt_label.xanchor = 0.5
+
+            # Yes/No
+
+            rrframe(style.yesno_frame)
+            del style.yesno_frame.yminimum
+            style.yesno_frame.ypadding = .05
+            style.yesno_frame.xpadding = rrslider_radius
+            style.yesno_frame.xmargin = .05
+            style.yesno_frame.ypos = .1
+            style.yesno_frame.yanchor = 0
+
+            style.yesno_label.color = label
+            style.yesno_label.drop_shadow = None
+
+            # File Picker
+
+            rrframe(style.file_picker_frame)
+            style.file_picker_frame.xmargin = 6
+            style.file_picker_frame.ymargin = 6
+
+            style.file_picker_frame_vbox.box_spacing = 4            
+            style.file_picker_nav_button.xminimum = 0
+
+            style.file_picker_navbox.box_spacing = spacing
+            del style.file_picker_navbox.xpos
+
+            style.file_picker_entry.background = RoundRect(widget, less_rounded)
+            style.file_picker_entry.hover_background = RoundRect(widget_hover, less_rounded)
+            style.file_picker_entry.xpadding = _roundrect_radius
+            style.file_picker_entry.xmargin = 2
+
+            style.file_picker_text.size = small
+            style.file_picker_text.drop_shadow = None
+            style.file_picker_text.color = widget_text
+            style.file_picker_new.color = widget_selected
+
+            style.file_picker_old.minwidth = 40
+            style.file_picker_new.minwidth = 40
+            
+            style.file_picker_old.text_align = 1.0
+            style.file_picker_new.text_align = 1.0
+            
+            if config.script_version is None or config.script_version > (6, 0, 0):
+                style.file_picker_text.insensitive_color = disabled_text
+                style.file_picker_entry.insensitive_background = RoundRect(disabled, less_rounded)
+
+            
+            config.file_quick_access_pages = 8
+
+            # In-game.
+
+            if rounded_window:
+
+                style.window.background = RoundRect(window, less_rounded)
+                style.window.xpadding = 6
+                style.window.ypadding = 6
+                style.window.xmargin = 6
+                style.window.ymargin = 6
+
+            else:
+                
+                style.window.background = Solid(window)
+                style.window.xpadding = 6
+                style.window.ypadding = 6
+                style.window.xmargin = 0
+                style.window.ymargin = 0
+                
+                
+            style.default.size = size
+            style.default.drop_shadow = None
+
+            rrframe(style.frame)
+            style.frame.xpadding = 6
+            style.frame.ypadding = 6
+            style.frame.xmargin = 6
+            style.frame.ymargin = 6
+
+            if button_menu:
+                _button_menu()
+
+            if launcher:
+                style.launcher_mid_vbox.xpos = 80
+                style.launcher_mid_vbox.ypos = 50
+
+                style.launcher_bottom_vbox.xpos = 80
+                style.launcher_bottom_vbox.ypos = 360
+                style.launcher_bottom_vbox.yanchor = 1.0
+
+                style.launcher_button.xpos = 20
+                style.launcher_button.xminimum = 240
+
+                style.launcher_title_label.color = label
+                style.launcher_title_label.size = 28
+                
+                style.launcher_text.xpos = 140
+                style.launcher_text.xanchor = 0.5
+                style.launcher_text.xmaximum = 240
+                style.launcher_text.color = label
+                style.launcher_text.text_align = 0.5
+                
+                
+                style.launcher_label.xpos = 140
+                style.launcher_label.xanchor = 0.5
+                style.launcher_label.xmaximum = 240
+                style.launcher_label.color = label
+                style.launcher_label.text_align = 0.5
+                
+                style.launcher_input.xpos = 140
+                style.launcher_input.xanchor = 0.5
+                style.launcher_input.xmaximum = 240
+                style.launcher_input.color = widget
+                style.launcher_input.text_align = 0.5
+                
+                store._launcher_per_page = 9
+                
+        theme.roundrect = theme_roundrect
+
+        def theme_roundrect_red(**params):
+            """
+            This sets up a red/pink variant of the roundrect theme.
+            """
+            
+            args = dict(widget=(150, 50, 50, 255),
+                        widget_hover=(200, 50, 50, 255),
+                        widget_text=(255, 225, 225, 255),
+                        frame=(225, 115, 115, 192),
+                        mm_root=Solid((255, 225, 225, 255)),
+                        gm_root=Solid((255, 225, 225, 255)),
+                        )
+
+            args.update(params)
+            theme.roundrect(**args)
+
+        theme.roundrect_red = theme_roundrect_red
+

common/_developer.rpym

@@ -0,0 +1,469 @@
+
+# This file contains the developer screen, which contains tools that might
+# be of interest to people making Ren'Py games.
+
+label _developer_screen:
+
+    python hide:
+
+        ui.window(style=style.gm_root)
+        ui.null()
+        
+        ui.frame(xpos=10, ypos=10, style=style.menu_frame)
+        ui.vbox(box_first_spacing=10)
+        layout.label(u"Developer Menu", None)
+
+        sg = "developer_menu"
+
+        layout.button(u"Return", None, clicked=ui.returns(True), size_group=sg)
+        layout.button(u"Reload Game (Shift+R)", None, clicked=ui.callsinnewcontext("_save_reload_game"), size_group=sg)
+        layout.button(u"Variable Viewer", None, clicked=ui.jumps("_debugger_screen"), size_group=sg)
+        layout.button(u"Theme Test", None, clicked=ui.jumps("_theme_test"), size_group=sg)
+        layout.button(u"Style Hierarchy", None, clicked=ui.jumps("_style_hierarchy"), size_group=sg)
+        layout.button(u"FPS Meter", None, clicked=ui.jumps("_fps_meter"), size_group=sg)
+        layout.button(u"Image Location Picker", None, clicked=ui.jumps("_image_location_picker"), size_group=sg)
+        
+        ui.close()
+        ui.interact()
+        
+    return 
+        
+label _debugger_screen:
+
+    python hide:
+
+        ui.window(style=style.gm_root)
+        ui.null()
+
+        ui.frame(ymargin=10, xmargin=10, style=style.menu_frame)
+        ui.side(['t', 'c', 'r', 'b'])
+
+        layout.label("Variable Viewer", None)
+
+        entries = [ ]
+        
+        ebc = renpy.game.log.ever_been_changed
+        ebc = list(ebc)
+        ebc.sort()
+
+        ebc.remove("nvl_list")
+
+        import repr
+        aRepr = repr.Repr()
+        aRepr.maxstring = 40
+
+        for var in ebc:
+            if not hasattr(store, var):
+                continue
+
+            if var.startswith("__00"):
+                continue
+
+            if var.startswith("_") and not var.startswith("__"):
+                continue
+
+            val = aRepr.repr(getattr(store, var))
+            entries.append((0, (var + " = " + val).replace("{", "{{")))
+
+        if entries:
+            vp = ui.viewport(mousewheel=True)
+            layout.list(entries)
+            ui.bar(adjustment=vp.yadjustment, style='vscrollbar')
+        else:
+            layout.prompt("No variables have changed since the game started.", None)
+            ui.null()
+
+        layout.button(u"Return to the developer menu", None, clicked=ui.returns(True))
+
+        ui.close()
+        
+        ui.interact()
+        
+    jump _developer_screen
+
+label _theme_test:
+
+    python hide:
+
+        # Never gets pickled
+        def role(b):
+            if b:
+                return "selected_"
+            else:
+                return ""
+        
+        toggle_var = True
+        adj = ui.adjustment(100, 25, page=25)
+        
+        while True:
+
+            ui.window(style=style.gm_root)
+            ui.null()
+
+            # Buttons
+            ui.hbox(box_spacing=10, xpos=10, ypos=10)
+
+            ui.vbox(box_spacing=10)
+
+            sg = "theme_test"
+
+            ui.frame(style='menu_frame')
+            ui.vbox()
+            layout.label("Button", None)
+            ui.textbutton("Button", size_group=sg, clicked=ui.returns("gndn"))
+            ui.textbutton("Button (Selected)", size_group=sg, clicked=ui.returns("gndn"), role=role(True))
+            ui.textbutton("Small", clicked=ui.returns("gndn"), style='small_button')
+            ui.close()
+
+            ui.frame(style='menu_frame')
+            ui.vbox()
+            layout.label("Radio Button", None)
+            ui.textbutton("True", size_group=sg, clicked=ui.returns("set"), role=role(toggle_var), style='radio_button')
+            ui.textbutton("False", size_group=sg, clicked=ui.returns("unset"), role=role(not toggle_var), style='radio_button')
+            ui.close()
+
+            ui.frame(style='menu_frame')
+            ui.vbox()
+            layout.label("Check Button", None)
+            ui.textbutton("Check Button", size_group=sg, clicked=ui.returns("toggle"), role=role(toggle_var), style='check_button')
+            ui.close()
+
+            ui.frame(style='menu_frame')
+            ui.vbox(box_spacing=2)
+            ui.bar(adjustment=adj, style='bar', xmaximum=200)
+            ui.bar(adjustment=adj, style='slider', xmaximum=200)
+            ui.bar(adjustment=adj, style='scrollbar', xmaximum=200)
+            ui.close()
+            
+            ui.close() # vbox
+
+            ui.frame(style='menu_frame')
+            ui.hbox(box_spacing=2)
+            ui.bar(adjustment=adj, style='vbar', ymaximum=200)
+            ui.bar(adjustment=adj, style='vslider', ymaximum=200)
+            ui.bar(adjustment=adj, style='vscrollbar', ymaximum=200)
+            ui.close()
+            
+            ui.frame(style='menu_frame', xmaximum=0.95)
+            ui.vbox(box_spacing=20)
+            layout.prompt("This a prompt. Hopefully, we've made this long enough to wrap around at least once.", None)
+            ui.close()
+
+            ui.close() # hbox
+
+            ui.frame(style='menu_frame', xalign=.01, yalign=.99)
+            ui.textbutton("Return to the developer menu", clicked=ui.returns("return"))
+            
+            rv = ui.interact()
+            if rv == "return":
+                renpy.jump("_developer_screen")
+
+            elif rv == "set":
+                toggle_var = True
+            elif rv == "unset":
+                toggle_var = False
+            elif rv == "toggle":
+                toggle_var = not toggle_var
+
+label _style_hierarchy:
+
+    python hide:
+
+        ui.window(style=style.gm_root)
+        ui.null()
+
+        ui.frame(ymargin=10, xmargin=10, style=style.menu_frame)
+        ui.side(['t', 'c', 'r', 'b'], spacing=2)
+
+        layout.label("Style Hierarchy", None)
+
+        hier = renpy.style.style_hierarchy()
+
+        entries = [ (i[0], i[1] + " - " + str(i[2])) for i in hier if i[2] ]
+        
+        vp = ui.viewport(mousewheel=True)
+        layout.list(entries)
+        ui.bar(adjustment=vp.yadjustment, style='vscrollbar')
+
+        layout.button(u"Return to the developer menu", None, clicked=ui.returns(True))
+        
+        ui.close()
+        
+        ui.interact()
+        
+    jump _developer_screen
+    
+
+init -1050 python:
+    config.missing_background = "black"
+    
+init 1050 python:
+    
+    if renpy.game.options.remote:
+            
+        config.window_title = "Preview: " + config.window_title
+        
+        class Remote(renpy.Displayable):
+            
+            def render(self, width, height, st, at):
+                return renpy.Render(0, 0)
+                            
+            def event(self, ev, x, y, st):
+                renpy.remote.remote()
+                renpy.timeout(.05)
+                
+        config.underlay.append(Remote())
+        del Remote
+        
+
+    if config.developer:
+
+        # This is used to indicate that a scene has just occured,
+        # and so if the next thing is a missing_show, we should
+        # blank the screen.
+        __missing_scene = False
+
+        # This returns the __missing dictionary from the current
+        # context object.
+        def __missing():
+            try:
+                return renpy.context().__missing
+            except AttributeError:
+                rv = dict()
+                renpy.context().__missing = rv
+                return rv
+        
+        def __missing_show_callback(name, what, layer):
+            if layer != 'master':
+                return False
+
+            global __missing_scene
+            if __missing_scene:
+                renpy.show(name, what=config.missing_background)
+            __missing_scene = False
+                
+            what = " ".join(what).replace("{", "{{")
+            __missing()[name[0]] = what
+            return True
+
+        def __missing_hide_callback(name, layer):
+            if layer != 'master':
+                return False
+
+            global __missing_scene
+            __missing_scene = False
+
+            __missing().pop(name[0], None)
+            return True
+            
+        def __missing_scene_callback(layer):
+            if layer != 'master':
+                return False
+
+            global __missing_scene
+            __missing_scene = True
+            __missing().clear()
+
+            return True
+            
+        def __missing_overlay():
+            missing = __missing()
+
+            if not missing:
+                return
+
+            ui.vbox(xalign=0.5, yalign=0.0)
+            ui.text(_("Undefined Images"), xalign=0.5)
+
+            for what in sorted(missing.values()):
+                ui.text(what, xalign=0.5)
+
+            ui.close()
+
+                
+        config.missing_scene = __missing_scene_callback
+        config.missing_show = __missing_show_callback
+        config.missing_hide = __missing_hide_callback
+        config.overlay_functions.append(__missing_overlay)
+
+init -1050 python:
+
+    class __FPSMeter(object):
+
+        def __init__(self):
+            self.last_frames = None
+            self.last_time = None
+
+        def __call__(self, st, at):
+
+            if self.last_time is not None:
+                frames = config.frames - self.last_frames
+                time = st - self.last_time
+
+                text = "FPS: %.1f" % (frames / time)
+
+            else:
+                text = "FPS: --.-"
+
+            self.last_frames = config.frames
+            self.last_time = st
+
+            return Text(text, xalign=1.0), .5
+    
+label _fps_meter:
+
+    python hide:
+        def fps_overlay():
+            ui.add(DynamicDisplayable(__FPSMeter()))
+        
+        # We normally don't want to change this at runtime... but here
+        # it's okay, because we don't want to save the FPS meter anyway.
+        #
+        # Do as I say, not as I do.
+        config.overlay_functions.append(fps_overlay)
+
+    return
+
+init python:
+    
+    # This is a displayable that can keep track of the mouse coordinates,
+    # and show them to the user.
+    class __ImageLocationPicker(renpy.Displayable):
+
+        def __init__(self, fn, **kwargs):
+            super(__ImageLocationPicker, self).__init__(**kwargs)
+            
+            self.child = Image(fn)
+
+            self.mouse = None
+            self.point1 = None
+            self.point2 = None
+            
+        def render(self, width, height, st, at):
+            rv = renpy.Render(width, height)
+
+            cr = renpy.render(self.child, width, height, st, at)
+            rv.blit(cr, (0, 0))
+
+            text = [ ]
+            
+
+            if self.point1 and self.point2 and not self.point1 == self.point2:
+                x1, y1 = self.point1
+                x2, y2 = self.point2
+
+                x1 = min(x1, cr.width)
+                x2 = min(x2, cr.width)
+                y1 = min(y1, cr.height)
+                y2 = min(y2, cr.height)
+                
+                minx = min(x1, x2)
+                miny = min(y1, y2)
+                maxx = max(x1, x2)
+                maxy = max(y1, y2)
+                
+                w = maxx - minx
+                h = maxy - miny
+
+                if w and h:
+
+                    sr = renpy.render(Solid("#0ff4"), w, h, st, at)
+                    rv.blit(sr, (minx, miny))
+
+                    text.append("Imagemap rectangle: %r" % ((minx, miny, maxx, maxy),))
+                    text.append("Cropping rectangle: %r" % ((minx, miny, w, h),))
+                
+            if self.mouse:
+                mx, my = self.mouse
+                if mx < cr.width and my < cr.height:
+                    text.append(_("Mouse position: %r") % (self.mouse,))
+                    
+            text.append(_("Right-click or escape to quit."))
+                
+            td = Text("\n".join(text), size=14, color="#fff", outlines=[ (1, "#000", 0, 0 ) ])
+            tr = renpy.render(td, width, height, st, at)
+
+            rv.blit(tr, (0, height - tr.height))
+            
+            return rv
+
+        def event(self, ev, x, y, st):
+            import pygame
+
+            self.mouse = (x, y)
+            renpy.redraw(self, 0)
+
+            if ev.type == pygame.MOUSEBUTTONDOWN and ev.button == 1:
+                self.point1 = (x, y)
+                self.point2 = (x, y)
+
+            elif ev.type == pygame.MOUSEMOTION and ev.buttons[0]:
+                self.point2 = (x, y)
+                
+            elif ev.type == pygame.MOUSEBUTTONUP and ev.button == 1:
+                self.point2 = (x, y)
+                
+
+label _image_location_picker:
+
+    scene black
+    
+    python hide:
+
+        image_files = [
+            fn
+            for dir, fn in renpy.loader.listdirfiles()
+            if fn.lower().endswith(".jpg") or fn.lower().endswith(".png")
+            if not fn[0] == "_"
+            ]
+
+        image_files.sort()
+        
+        
+        xadjustment = ui.adjustment()
+        yadjustment = ui.adjustment()
+
+        
+        while True:
+
+            ui.frame()
+            ui.vbox()
+
+            layout.label(u"Image Location Picker", None)
+
+            ui.textbutton(_(u"Done"), clicked=ui.returns(False), size_group="files")
+            
+            ui.side(['c', 'b', 'r'], spacing=5)
+            vp = ui.viewport(xadjustment=xadjustment, yadjustment=yadjustment, mousewheel=True)
+
+            ui.vbox()
+
+            for fn in image_files:
+                ui.button(clicked=ui.returns(fn), size_group="files", xminimum=1.0)
+                ui.text(fn, style="button_text", xalign=0.0)
+                
+            ui.close()
+
+            ui.bar(adjustment=xadjustment, style='scrollbar')
+            ui.bar(adjustment=yadjustment, style='vscrollbar')
+            ui.close()
+
+            ui.close()
+            
+            rv = ui.interact()
+
+            if rv is False:
+                renpy.jump("_developer_screen")
+
+            # Now, allow the user to pick the image.
+
+            ui.keymap(game_menu=ui.returns(True))
+            ui.add(__ImageLocationPicker(rv))
+            ui.interact()
+
+                
+
+        # ...
+
+        renpy.jump("_image_location_picker")
+        

common/_layout/classic_joystick_preferences.rpym

@@ -0,0 +1,109 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('joystick_preferences')
+    
+    style.js_frame = Style(style.menu_frame, help="frame used for changing a joystick binding")
+    style.js_frame_box = Style(style.vbox, help="vbox used for changing a joystick binding")
+    style.js_function_prompt = Style(style.prompt, help="the name of the joystick binding to change (window)")
+    style.js_function_prompt_text = Style(style.prompt_text, help="the name of the joystick binding to change (text)")
+    style.js_action_prompt = Style(style.prompt, help="prompting the user how to change a joystick binding (window)")
+    style.js_action_prompt_text = Style(style.prompt_text, help="prompting the user how to change a joystick binding (text)")
+
+    style.js_prefs_frame = Style(style.menu_frame, help="frame containing all joystick bindings")
+    style.js_prefs_box = Style(style.vbox, help="box containing all joystick bindings")
+    style.js_prefs_button = Style(style.button, help="button containing a joystick binding")
+    style.js_prefs_button_text = Style(style.button_text, help="button containing a joystick binding (text)")
+    
+    style.js_prefs_label = Style(style.label, help="joystick preferences label (window)") 
+    style.js_prefs_label_text = Style(style.label_text, help="joystick preferences label (text)") 
+
+    style.js_frame.ypos = .1
+    style.js_frame.ypadding = .05
+    style.js_frame.xmargin = .1
+    style.js_frame_box.box_spacing = 30
+
+    style.js_prefs_frame.xpos = 10
+    style.js_prefs_frame.ypos = 10
+
+    style.js_prefs_button.xminimum = 0.5
+    style.js_prefs_box.box_first_spacing = 10
+    
+    config.joystick_keys = [
+        (u'Left', 'joy_left'),
+        (u'Right', 'joy_right'),
+        (u'Up', 'joy_up'),
+        (u'Down', 'joy_down'),
+        (u'Select/Dismiss', 'joy_dismiss'),
+        (u'Rollback', 'joy_rollback'),
+        (u'Hold to Skip', 'joy_holdskip'),
+        (u'Toggle Skip', 'joy_toggleskip'),
+        (u'Hide Text', 'joy_hide'),
+        (u'Menu', 'joy_menu'),
+        ]
+    
+    def _joystick_select_binding():
+
+        for label, key in config.joystick_keys:
+
+            def my_clicked(label=label, key=key):
+                return (label, key)
+
+            layout.button(_(label) + " - " + _(_preferences.joymap.get(key, u"Not Assigned")), "prefs_js", clicked=my_clicked, index=label)
+    
+    def _joystick_get_binding():
+        ui.saybehavior()
+        ui.add(renpy.display.joystick.JoyBehavior())
+
+    def _joystick_take_binding(binding, key):
+
+        if not isinstance(binding, basestring):
+            if key in _preferences.joymap:
+                del _preferences.joymap[key]
+        else:
+            _preferences.joymap[key] = binding
+        
+            
+    def _joystick_preferences():
+
+            def set_binding(label, key):
+                layout.navigation(None)
+
+                ui.window(style='js_frame')
+                ui.vbox(style='js_frame_box')
+                layout.prompt(_(u"Joystick Mapping") + " - " + _(label), "js_function")
+                layout.prompt(u'Move the joystick or press a joystick button to create the mapping. Click the mouse to remove the mapping.', 'js_action')
+                ui.close()
+
+                _joystick_get_binding()
+                binding = ui.interact(mouse="gamemenu")
+                _joystick_take_binding(binding, key)
+                
+                return True
+
+            ui.window(style='js_prefs_frame')
+            ui.vbox(style='js_prefs_box')
+
+            layout.label("Joystick Configuration", "js_prefs")
+            
+            for label, key in config.joystick_keys:
+
+                def clicked(label=label, key=key):
+                    return renpy.invoke_in_new_context(set_binding, label, key)
+
+                layout.button(_(label) + " - " + _(_preferences.joymap.get(key, u"Not Assigned")), "js_prefs", clicked=clicked, index=label)
+            
+            ui.close()
+
+label joystick_preferences_screen:
+
+    while True:
+        python:
+            layout.navigation("joystick_preferences")
+            _joystick_preferences()
+            ui.interact(mouse="gamemenu")
+
+            
+        

common/_layout/classic_load_save.rpym

@@ -0,0 +1,358 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('load_save')
+    
+    # Define styles
+    style.file_picker_entry = Style(style.large_button, help="used to select a file to load or save")
+    style.file_picker_entry_box = Style(style.hbox, help="the box inside a file picker entry")
+
+    style.file_picker_text = Style(style.large_button_text, help="text inside a file picker entry")
+    style.file_picker_empty_slot = Style(style.file_picker_text, help="text inside an empty file picker entry slot")
+    style.file_picker_extra_info = Style(style.file_picker_text)
+    style.file_picker_new = Style(style.file_picker_text)
+    style.file_picker_old = Style(style.file_picker_text)
+
+    style.file_picker_frame = Style(style.menu_frame, help="the frame enclosing the entire file picker")
+    style.file_picker_frame_box = Style(style.vbox, help="the box containing the navbox and the grid of file picker entries")
+
+    style.file_picker_navbox = Style(style.hbox, help="the box containing navigation buttons")
+
+    style.file_picker_nav_button = Style(style.small_button, help="a file picker navigation button")
+    style.file_picker_nav_button_text = Style(style.small_button_text, help="file picker navigation button text")
+
+    style.file_picker_grid = Style(style.default, help="a grid containing file picker navigation buttons")
+
+    # Adjust styles.
+    style.file_picker_entry.xminimum = 0.5
+
+    style.file_picker_frame.xmargin = 6
+    style.file_picker_frame.ymargin = 6
+
+    style.file_picker_frame_box.box_spacing = 4            
+    style.file_picker_entry_box.box_spacing = 4
+    
+    # The number of columns per page of files.
+    config.file_page_cols = 2
+
+    if config.screen_width <= 640:
+        # The number of rows per page of files.
+        config.file_page_rows = 4
+
+        # The number of quick access pages.
+        config.file_quick_access_pages = 6
+    else:
+        config.file_page_rows = 5
+        config.file_quick_access_pages = 8
+
+    # True if we want to disable the file pager.
+    config.disable_file_pager = False
+
+    # True to suppress the display of thumbnails.
+    config.disable_thumbnails = False
+
+    # The default thumbnail to use when no file exists.
+    config.load_save_empty_thumbnail = None
+    
+    # How we format time in a file entry.
+    config.time_format = "%b %d, %H:%M"
+
+    # How we format a file entry.
+    config.file_entry_format = "%(time)s\n%(save_name)s"
+
+    # True if we should prompt before loading a game.
+    _load_prompt = True
+
+    # This is used to store scratch data that's used by the
+    # library, but shouldn't be saved out as part of the savegame.
+    __scratch = object()
+    __scratch.file_picker_page = None
+    
+    def _render_savefile(index, name, extra_info, screenshot, mtime, newest, clicked):
+
+        import time
+        
+        ui.button(style=style.file_picker_entry[index],
+                  clicked=clicked,
+                  role=("selected_" if newest else ""),
+                  keymap={ "save_delete" : ui.returns(("unlink", name)) }
+                  )
+
+        ui.hbox(style=style.file_picker_entry_box[index])
+
+        if not config.disable_thumbnails:
+            ui.add(screenshot)
+
+        if newest:
+            ui.text(name + ". ", style=style.file_picker_new[index])
+        else:
+            ui.text(name + ". ", style=style.file_picker_old[index])
+            
+        s = config.file_entry_format % dict(
+            time=time.strftime(config.time_format,
+                               time.localtime(mtime)),
+            save_name=extra_info)
+
+        ui.text(s, style=style.file_picker_extra_info[index])
+
+        ui.close()
+        
+    def _render_new_slot(index, name, clicked):
+
+        ui.button(style=style.file_picker_entry[index],
+                  clicked=clicked)
+
+        
+        ui.hbox(style=style.file_picker_entry_box[index])
+
+        if not config.disable_thumbnails:
+
+            if config.load_save_empty_thumbnail:
+                ui.add(config.load_save_empty_thumbnail)
+            else:
+                ui.null(width=config.thumbnail_width,
+                        height=config.thumbnail_height)
+        
+        ui.text(name + ". ", style=style.file_picker_old[index])
+
+        ui.text(_(u"Empty Slot."), style=style.file_picker_empty_slot[index])
+        ui.close()
+
+
+    # Returns the names of the various pages that the file picker knows
+    # about.
+    def _file_picker_pages():
+
+        rv = [ ]
+
+        if config.has_autosave:
+            rv.append(u"Auto")
+
+        if config.has_quicksave:
+            rv.append(u"Quick")
+
+        for i in range(1, config.file_quick_access_pages + 1):
+            rv.append(str(i))
+
+        return rv
+
+
+    # This function is given a page, and should map it to the names
+    # of the files on that page.
+    def _file_picker_page_files(page):
+
+        per_page = config.file_page_cols * config.file_page_rows
+        rv = [ ]
+
+        if config.has_autosave:
+            if page == 0:
+                for i in range(1, per_page + 1):
+                    rv.append(("auto-" + str(i), _(u"a") + str(i), True))
+
+                return rv
+            else:
+                page -= 1
+
+        if config.has_quicksave:
+            if page == 0:
+                for i in range(1, per_page + 1):
+                    rv.append(("quick-" + str(i), _(u"q") + str(i), True))
+
+                return rv
+            else:
+                page -= 1
+
+        for i in range(per_page * page + 1, per_page * page + 1 + per_page):
+            rv.append(("%d" % i, "%d" % i, False))
+
+        return rv
+
+    # Given a filename, returns the page that filename is on. 
+    def _file_picker_file_page(filename):
+
+        per_page = config.file_page_cols * config.file_page_rows
+
+        base = 0
+
+        if config.has_autosave:
+            if filename.startswith("auto-"):
+                return base
+            else:
+                base += 1
+
+        if config.has_quicksave:
+            if filename.startswith("quick-"):
+                return base
+            else:
+                base += 1
+
+        return base + int((int(filename) - 1) / per_page)
+
+    # Processes a screenshot.
+    def _file_picker_process_screenshot(s):
+        return s
+    
+    # This displays a file picker that can chose a save file from
+    # the list of save files.
+    def _file_picker(screen, save):
+
+        # Should we update the list of saved games?
+        update = True
+        
+        while True:
+
+
+            if update:
+
+                update = False
+
+                # The number of slots in a page.
+                file_page_length = config.file_page_cols * config.file_page_rows
+
+                # The list of saved games.
+                saved_games = renpy.list_saved_games(regexp=r'(auto-|quick-)?[0-9]+')
+
+                # Figure out which game is the newest and so on.
+                newest = None
+                newest_mtime = None
+                save_info = { }
+
+                for fn, extra_info, screenshot, mtime in saved_games:
+                    screenshot = _file_picker_process_screenshot(screenshot)
+                    save_info[fn] = (extra_info, screenshot, mtime)
+
+                    if not fn.startswith("auto-") and mtime > newest_mtime:
+                        newest = fn
+                        newest_mtime = mtime
+
+                # The index of the first entry in the page.
+                fpp = __scratch.file_picker_page
+
+                if fpp is None:
+                    if newest:
+                        fpp = _file_picker_file_page(newest)
+                    else:
+                        fpp = _file_picker_file_page("1")
+
+            
+            if fpp < 0:
+                fpp = 0
+
+            __scratch.file_picker_page = fpp
+
+            # Show navigation
+            layout.navigation(screen)
+
+            ui.window(style='file_picker_frame')
+            ui.vbox(style='file_picker_frame_box') # whole thing.
+
+            if not config.disable_file_pager:
+
+                # Draw the navigation.
+                ui.hbox(style='file_picker_navbox') # nav buttons.
+
+                def tb(cond, label, clicked, selected):
+                    layout.button(label,
+                                  "file_picker_nav",
+                                  enabled=cond,
+                                  clicked=clicked,
+                                  selected=selected)
+
+                # Previous
+                tb(fpp > 0, u'Previous', ui.returns(("fppdelta", -1)), selected=False)
+    
+                # Quick Access
+                for i, name in enumerate(_file_picker_pages()):
+                    tb(True, name, ui.returns(("fppset", i)), fpp == i)
+
+                # Next
+                tb(True, u'Next', ui.returns(("fppdelta", +1)), False)
+
+                ui.close()
+
+            # This draws a single slot.
+            def entry(name, filename, offset, ro):
+                clicked = ui.returns(("return", filename))
+                
+                if filename not in save_info:
+                    if (not save) or ro:
+                        clicked = None
+
+                    _render_new_slot(offset, name, clicked)
+                else:
+                    if save and ro:
+                        clicked = None
+
+                    extra_info, screenshot, mtime = save_info[filename]
+                    _render_savefile(offset,
+                                     name,
+                                     extra_info,
+                                     screenshot,
+                                     mtime,
+                                     newest == filename,
+                                     clicked)
+
+            ui.grid(config.file_page_cols,
+                    config.file_page_rows,
+                    style='file_picker_grid',
+                    transpose=True) # slots
+
+            for i, (filename, name, ro) in enumerate(_file_picker_page_files(fpp)):
+                entry(name, filename, i, ro)
+
+            ui.close() # slots
+            ui.close() # whole thing
+
+            result = ui.interact(mouse="gamemenu")
+            type, value = result
+
+            if type == "unlink":
+                if layout.yesno_prompt(screen, layout.DELETE_SAVE):
+                    renpy.unlink_save(value)
+                    update = True
+                    
+            if type == "return":
+                return value
+
+            if type == "fppdelta":
+                fpp += value
+
+            if type == "fppset":
+                fpp = value
+
+
+label save_screen:
+
+    python hide:
+        while True:
+            fn = _file_picker("save", True)
+
+            if renpy.can_load(fn):
+                if not layout.yesno_prompt("save", layout.OVERWRITE_SAVE):
+                    continue
+
+            renpy.save(fn, extra_info=store.save_name)
+
+
+label load_screen:
+
+    python hide:
+
+        while True:
+            fn = _file_picker("load", False)
+            
+            if _load_prompt:
+                if not layout.yesno_prompt("load", layout.LOADING):
+                    continue
+
+            renpy.load(fn)
+            
+            
+            
+init python hide:
+    def auto_save_extra_info():
+        return save_name
+    config.auto_save_extra_info = auto_save_extra_info
+    

common/_layout/classic_main_menu.rpym

@@ -0,0 +1,60 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('main_menu')
+
+    style.mm_menu_frame = Style(style.menu_frame, help="frame containing main menu")
+    style.mm_menu_frame_box = Style(style.vbox, help="box containing main menu buttons")
+
+    style.mm_button = Style(style.button, help="main menu button")
+    style.mm_button_text = Style(style.button_text, help="main menu button (text)")
+
+    style.mm_button.size_group = "mm"
+
+    style.mm_menu_frame.xpos = 5.0/6.0
+    style.mm_menu_frame.xanchor = 0.5
+    style.mm_menu_frame.ypos = 0.9
+    style.mm_menu_frame.yanchor = 1.0
+    
+label main_menu_screen:
+
+    python hide:
+
+        # Ignore right-click while at the main menu.
+        ui.keymap(game_menu=ui.returns(None))
+        
+        # Show the background.
+        ui.window(style='mm_root')
+        ui.null()
+
+        ui.frame(style='mm_menu_frame')
+        ui.vbox(style='mm_menu_frame_box')
+
+        for e in config.main_menu:
+
+            if len(e) == 3:
+                label, clicked, enabled = e
+                shown = "True"
+            else:
+                label, clicked, enabled, shown = e
+
+            if not eval(shown):
+                continue
+            
+            # This checks to see if clicked is a string. If so, we want clicked
+            # to jump us out of the current context.
+            if isinstance(clicked, basestring):
+                clicked=ui.jumpsoutofcontext(clicked)
+
+            # Create each button.
+            layout.button(label, "mm", enabled=eval(enabled), clicked=clicked)
+
+        ui.close()
+
+        ui.interact(mouse="mainmenu")
+        
+    return
+            
+    

common/_layout/classic_navigation.rpym

@@ -0,0 +1,53 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('navigation')
+
+    style.gm_nav_frame = Style(style.menu_frame, help="game menu navigation frame")
+    style.gm_nav_box = Style(style.vbox, help="box containing game menu navigation buttons")
+
+    style.gm_nav_button = Style(style.button, help="game menu navigation button")
+    style.gm_nav_button_text = Style(style.button_text, help="game menu navigation button (text)")
+
+    style.gm_nav_button.size_group = "gm_nav_button"
+    
+    style.gm_nav_frame.xpos = 5.0/6.0
+    style.gm_nav_frame.xanchor = 0.5
+    style.gm_nav_frame.ypos = 0.95
+    style.gm_nav_frame.yanchor = 1.0
+    
+    def _navigation(screen=None):
+
+        # Display the game menu background
+        ui.window(style=style.gm_root[screen])
+        ui.null()
+
+        if screen is None:
+            return
+
+        # Display the navigation frame.
+        ui.frame(style='gm_nav_frame')
+        ui.vbox(focus='gm_nav', style='gm_nav_box')
+
+        for e in config.game_menu:
+
+            if len(e) == 4:
+                 key, label, clicked, enabled = e
+                 shown = "True"
+            else:
+                 key, label, clicked, enabled, shown = e
+
+            if not eval(shown):
+                continue
+                 
+            layout.button(label,
+                          "gm_nav",
+                          selected=(screen==key),
+                          enabled=eval(enabled),
+                          clicked=clicked)
+
+        ui.close()
+
+    layout.navigation = _navigation

common/_layout/classic_preferences.rpym

@@ -0,0 +1,86 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('preferences')
+    
+    # Load the common code.
+    renpy.load_module("_layout/classic_preferences_common")
+
+    # Create styles.
+    style.prefs_column = Style(style.vbox, help="preference columns")
+    style.prefs_left = Style(style.prefs_column, help="the left preference column")
+    style.prefs_center = Style(style.prefs_column, help="the center preference column")
+    style.prefs_right = Style(style.prefs_column, help="the right preference column")
+
+    # Customize styles.
+    style.prefs_pref_frame.xfill = True
+    style.prefs_column.xanchor = 0.5
+    
+    if config.screen_width <= 640:
+        style.prefs_pref_box.box_spacing = 6
+
+        style.prefs_column.xmaximum = 200
+        style.prefs_column.box_spacing = 5
+        style.prefs_frame.top_margin = 5
+        
+        style.prefs_left.xpos = 110
+        style.prefs_center.xpos = 320
+        style.prefs_right.xpos = 530
+
+        style.prefs_slider.xmaximum = 160
+        
+    else:
+        style.prefs_pref_box.box_spacing = 12
+
+        style.prefs_column.xmaximum = 250
+        style.prefs_column.box_spacing = 10
+        style.prefs_frame.top_margin = 10
+
+        style.prefs_left.xpos = 137
+        style.prefs_center.xpos = 400
+        style.prefs_right.xpos = 663
+
+        style.prefs_slider.xmaximum = 200
+        
+    style.prefs_pref_box.xfill = True
+    style.prefs_volume_box.xfill = True
+    style.prefs_pref_choicebox.xfill = True
+    style.prefs_button.xalign = 1.0
+    style.prefs_jump_button.xalign = 1.0
+    style.prefs_slider.xalign = 1.0
+    style.soundtest_button.xalign = 1.0
+
+    style.prefs_button.size_group = "prefs"
+    style.prefs_jump_button.size_group = "prefs"
+    
+    # Place preferences into groups.
+    config.preferences['prefs_left'] = [
+        config.all_preferences[u'Display'],
+        config.all_preferences[u'Transitions'],
+        config.all_preferences[u'Text Speed'],
+        config.all_preferences[u'Joystick...'],
+        ]
+
+    config.preferences['prefs_center'] = [
+        config.all_preferences[u'Skip'],
+        config.all_preferences[u'Begin Skipping'],
+        config.all_preferences[u'After Choices'],
+        config.all_preferences[u'Auto-Forward Time'],
+        ]
+
+    config.preferences['prefs_right'] = [
+        config.all_preferences[u'Music Volume'],
+        config.all_preferences[u'Sound Volume'],
+        config.all_preferences[u'Voice Volume'],
+        ]
+
+
+label preferences_screen:
+
+    python hide:
+        _prefs_screen_run(config.preferences)
+    
+    jump preferences_screen
+    

common/_layout/classic_preferences_common.rpym

@@ -0,0 +1,377 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+    
+    # Styles
+    style.prefs_frame = Style(style.default, help="the frame containing all of the preferences")
+    style.prefs_frame_box = Style(style.default, help="the box inside the frame containing all of the preferences")
+    
+    style.prefs_pref_frame = Style(style.menu_frame, help="a frame containing a single preference")
+    style.prefs_pref_box = Style(style.vbox, help="the box separating the preference label from the preference choices")
+    style.prefs_pref_choicebox = Style(style.vbox, help="the box containing the preference choices")
+
+    style.prefs_label = Style(style.label, help="a preference label (window)")
+    style.prefs_label_text = Style(style.label_text, help="a preference label (text)")
+
+    style.prefs_button = Style(style.radio_button, help="preference value button")
+    style.prefs_button_text = Style(style.radio_button_text, help="preference value button (text)")
+
+    style.prefs_slider = Style(style.slider, help="preference value slider bar")
+
+    style.prefs_volume_box = Style(style.vbox, help="box containing a volume slider and soundtest button")
+    style.prefs_volume_slider = Style(style.prefs_slider, help="volume slider bar")
+    
+    style.soundtest_button = Style(style.small_button, help="soundtest button")
+    style.soundtest_button_text = Style(style.small_button_text, help="soundtest button (text)")
+
+    style.prefs_jump = Style(style.prefs_pref_frame, help="jump preference frame")
+    style.prefs_jump_button = Style(style.button, help="jump preference button")
+    style.prefs_jump_button_text = Style(style.button_text, help="jump preference button (text)")
+    
+    # This is a map from the name of the style that is applied to
+    # a list of preferences that should be placed into a vbox
+    # with that style.
+    config.preferences = { }
+
+    # This is a map from preference name to that preference
+    # object, that can be used in rearranging preferences.
+    config.all_preferences = { }
+
+    # Should the soundtest button be before the volume slider?
+    config.soundtest_before_volume = False
+    
+    def _prefs_screen_run(prefs_map):
+
+        layout.navigation("preferences")
+        
+        ui.window(style='prefs_frame')
+        ui.fixed(style='prefs_frame_box')
+
+        for style, prefs in prefs_map.iteritems():
+
+            ui.vbox(style=style)
+            for i in prefs:
+                i.render()
+            ui.close()
+
+        ui.close()
+
+        ui.interact(mouse="gamemenu")
+
+    class _Preference(object):
+        """
+        This is a class that's used to represent a multiple-choice
+        preference.
+        """
+
+        def __init__(self, name, field, values, base=_preferences):
+            """
+            @param name: The name of this preference. It will be
+            displayed to the user.
+
+            @param variable: The field on the base object
+            that will be assigned the selected value. This field
+            must exist.
+
+            @param values: A list of value name, value, condition
+            triples. The value name is the name of this value that
+            will be shown to the user. The value is the literal
+            python value that will be assigned if this value is
+            selected. The condition is a condition that will be
+            evaluated to determine if this is a legal value. If no
+            conditions are true, this preference will not be
+            displayed to the user. A condition of None is always
+            considered to be True.
+
+            @param base: The base object on which the variable is
+               read from and set. This defaults to _preferences,
+               the user preferences object.
+            """
+
+            self.name = name
+            self.field = field
+            self.values = values
+            self.base = base
+
+            config.all_preferences[name] = self
+
+            
+        def render(self):
+            values = [ (name, val) for name, val, cond in self.values
+                       if cond is None or renpy.eval(cond) ]
+
+            if not values:
+                return
+
+            ui.window(style=style.prefs_pref_frame[self.name])
+            ui.vbox(style=style.prefs_pref_box[self.name])
+
+            layout.label(self.name, "prefs")
+
+            cur = getattr(self.base, self.field)
+
+            ui.hbox(style=style.prefs_pref_choicebox[self.name])
+
+            for name, value in values:
+                def clicked(value=value):
+                    setattr(self.base, self.field, value)
+                    return True
+
+                layout.button(name, "prefs",
+                              selected=(cur==value),
+                              clicked=clicked)
+
+            ui.close() # choicebox
+            ui.close() # vbox
+
+    class _VolumePreference(object):
+        """
+        This represents a preference that controls one of the
+        volumes in the system. It is represented as a slider bar,
+        and a button that can be pushed to play a sample sound on
+        a channel.
+        """
+
+        def __init__(self, name, mixer, enable='True', sound='None', channel=0):
+            """
+            @param name: The name of this preference, as shown to the user.
+
+            @param mixer: The mixer this preference controls.
+
+            @param enable: A string giving a python expression. If
+            the expression is evaluates to false, this preference
+            is not shown.
+
+            @param sound: A string that is evaluated to yield
+            another string. The yielded string is expected to give
+            a sound file, which is played as the sample sound. (We
+            apologize for the convolution of this.)
+
+            @param channel: The number of the channel the sample
+            sound is played on.                
+            """
+
+            self.name = name
+            self.mixer = mixer
+            self.enable = enable
+            self.sound = sound
+            self.channel = channel
+
+            config.all_preferences[name] = self
+
+        def render(self):
+
+            if not eval(self.enable):
+                return
+
+            sound = eval(self.sound)
+
+            ui.window(style=style.prefs_pref_frame[self.name])
+            ui.vbox(style=style.prefs_pref_box[self.name])
+
+            layout.label(self.name, "prefs")
+
+            ui.vbox(style=style.prefs_volume_box[self.name])
+            
+            if sound:
+                def clicked():
+                    renpy.sound.play(sound, channel=self.channel)
+            
+            if sound and config.soundtest_before_volume:
+                layout.button(u"Test", "soundtest", clicked=clicked, index=self.name)
+
+            def changed(v):
+                _preferences.set_volume(self.mixer, v / 128.0)
+                
+            ui.bar(128,
+                   int(_preferences.get_volume(self.mixer) * 128),
+                   changed=changed,
+                   style=style.prefs_volume_slider[self.name])
+
+            if sound and not config.soundtest_before_volume:
+                layout.button(u"Test", "soundtest", clicked=clicked, index=self.name)
+
+            ui.close()
+            ui.close()
+
+    class _SliderPreference(object):
+        """
+        A class that represents a preference that is controlled by a
+        slider.
+        """
+
+        def __init__(self, name, field, range, enable='True', base=_preferences):
+            """
+            @param name: The name of this preference, that is shown to the user.
+
+            @param range: An integer giving the maximum value of
+            this slider. The slider goes from 0 to range.
+
+            @param get: A function that's called to get the
+            initial value of the slider. It's called with no
+            arguments, and should return an integet between 0 and
+            range, inclusive.
+
+            @param set: A function that's called when the value of
+            the slider is set by the user. It is called with a
+            single integer, in the range 0 to range, inclusive.
+
+            @param enable: A string giving a python expression. If
+            the expression is evaluates to false, this preference
+            is not shown.
+            """
+
+            self.name = name
+            self.field = field
+            self.range = range
+            self.enable = enable
+            self.base = base
+            
+            config.all_preferences[name] = self
+
+        def get(self):
+            value = getattr(self.base, self.field)
+            if value == 0:
+                value = self.range
+            else:
+                value -= 1
+
+            return value
+
+        def set(self, value):
+            value += 1
+            if value == self.range + 1:
+                value = 0
+
+            setattr(self.base, self.field, value)
+            
+        def render(self):
+
+            if not eval(self.enable):
+                return
+
+            ui.window(style=style.prefs_pref_frame[self.name])
+            ui.vbox(style=style.prefs_pref_box[self.name])
+
+            layout.label(self.name, "prefs")
+
+            def changed(v):
+                self.set(v)
+
+            ui.bar(self.range,
+                   self.get(),
+                   changed=changed,
+                   style=style.prefs_slider[self.name])
+
+            ui.close()
+
+
+    class _JumpPreference(object):
+
+        def __init__(self, name, target, condition="True", show="True"):
+            self.name = name
+            self.target = target
+            self.condition = condition
+            self.show = show
+            
+            config.all_preferences[name] = self
+
+        def render(self):
+
+            if not eval(self.show):
+                return
+            
+            ui.window(style=style.prefs_jump[self.name])
+
+            if eval(self.condition):
+                clicked=ui.jumps(self.target)
+            else:
+                clicked=None
+
+            layout.button(self.name, 'prefs_jump', clicked=clicked)
+
+    def _remove_preference(name):
+        """
+        Removes the preference with the given name from the
+        preferences menu.
+        """
+
+        pref = config.all_preferences.get(name, None)
+        if not pref:
+            return
+
+        for k, v in config.preferences.iteritems():
+            if pref in v:
+                v.remove(pref)
+            
+init python hide:
+
+    # Enablers for some preferences.
+    config.sample_sound = None
+    config.sample_voice = None
+    config.has_transitions = True
+    config.has_cps = True
+    config.has_afm = True
+    config.has_skipping = True
+    config.has_skip_after_choice = True
+    config.always_has_joystick = False
+    config.has_joystick = True
+    
+
+    # Left
+
+    _Preference(u'Display', 'fullscreen', [
+        (u'Window', False, None),
+        (u'Fullscreen', True, None),
+        ])
+
+    _Preference(u'Transitions', 'transitions', [
+        (u'All', 2, 'config.has_transitions'),
+        (u'Some', 1, 'config.has_transitions and default_transition'),
+        (u'None', 0, 'config.has_transitions'),
+        ])
+
+    # Center
+
+    _Preference(u'Skip', 'skip_unseen', [
+        (u'Seen Messages', False, 'config.allow_skipping and config.has_skipping'),
+        (u'All Messages', True, 'config.allow_skipping and config.has_skipping'),
+        ])
+
+    _JumpPreference(u'Begin Skipping',
+                    '_return_skipping',
+                    'not main_menu',
+                    'config.allow_skipping and config.has_skipping')
+    
+    
+    _Preference(u'After Choices', 'skip_after_choices', [
+        (u'Stop Skipping', False, 'config.allow_skipping and config.has_skip_after_choice'),
+        (u'Keep Skipping', True, 'config.allow_skipping and config.has_skip_after_choice'),
+        ])
+
+    config.old_names['Keep Skipping'] = 'Continue Skipping' 
+
+    _SliderPreference(u'Text Speed', "text_cps", 150, 'config.has_cps')
+    _SliderPreference(u'Auto-Forward Time', "afm_time", 40, 'config.has_afm')
+
+    # Right
+
+    _VolumePreference(u"Music Volume",
+                      'music',
+                      'config.has_music')
+    _VolumePreference(u"Sound Volume",
+                      'sfx',
+                      'config.has_sound',
+                      'config.sample_sound')
+    _VolumePreference(u'Voice Volume',
+                      'voice',
+                      'config.has_voice',
+                      'config.sample_voice',
+                      2)
+
+    _JumpPreference(u'Joystick...',
+                    'joystick_preferences_screen',
+                    'renpy.display.joystick.enabled or config.always_has_joystick',
+                    'config.has_joystick')
+

common/_layout/classic_yesno_prompt.rpym

@@ -0,0 +1,60 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python hide:
+
+    layout.provides('yesno_prompt')
+    
+    # Define styles
+    style.yesno_frame = Style(style.menu_frame, help="frame containing a yes/no prompt and yes/no buttons")
+    style.yesno_frame_vbox = Style(style.vbox, help="box separating yes/no prompt from yes/no buttons")
+
+    style.yesno_prompt = Style(style.prompt, help="a yes/no prompt")
+    style.yesno_prompt_text = Style(style.prompt_text, help="a yes/no prompt (text)")
+
+    style.yesno_button_hbox = Style(style.hbox, help="the box separating yes and no buttons")
+    style.yesno_button = Style(style.button, help="a yes or no button")
+    style.yesno_button_text = Style(style.button_text, help="a yes or no button (text)")
+
+    # Alter styles.
+    style.yesno_frame.xfill = True
+    style.yesno_frame.xmargin = .05
+    style.yesno_frame.ypos = .1
+    style.yesno_frame.yanchor = 0
+    style.yesno_frame.ypadding = .05
+    
+    style.yesno_frame_vbox.xalign = 0.5
+    style.yesno_frame_vbox.yalign = 0.5
+    style.yesno_frame_vbox.box_spacing = 30
+    
+    style.yesno_button_hbox.xalign = 0.5
+    style.yesno_button_hbox.spacing = 100
+
+    style.yesno_button.size_group = "yesno"
+    
+    def yesno_prompt(screen, message):
+        renpy.transition(config.intra_transition)
+
+        layout.navigation(screen)
+
+        ui.window(style='yesno_frame')
+        ui.vbox(style='yesno_frame_vbox')
+
+        layout.prompt(message, "yesno")
+
+        ui.hbox(style='yesno_button_hbox')
+        
+        # The extra nulls are because we want equal whitespace surrounding
+        # the two buttons. It should work as long as we have xfill=True
+        layout.button(u"Yes", 'yesno', clicked=ui.returns(True))
+        layout.button(u"No", 'yesno', clicked=ui.returns(False))
+
+        ui.close()
+        ui.close()
+
+        rv = ui.interact(mouse="gamemenu")
+        renpy.transition(config.intra_transition)
+        return rv
+
+    layout.yesno_prompt = yesno_prompt
+    

common/_layout/grouped_main_menu.rpym

@@ -0,0 +1,72 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('main_menu')
+
+    style.mm_menu_frame = Style(style.menu_frame, help="frame containing main menu")
+    style.mm_outer_box = Style(style.vbox, help="outer box containing main menu buttons")
+    style.mm_inner_box = Style(style.hbox, help="inner box containing main menu buttons")
+    
+    style.mm_button = Style(style.button, help="main menu button")
+    style.mm_button_text = Style(style.button_text, help="main menu button (text)")
+
+    style.mm_menu_frame.xalign = 0.5
+    style.mm_menu_frame.yalign = 0.98
+    style.mm_inner_box.xalign = 0.5
+    
+    config.main_menu_per_group = 2
+
+
+label main_menu_screen:
+
+    python hide:
+        # Ignore right-click while at the main menu.
+        ui.keymap(game_menu=ui.returns(None))
+
+        # Show the background.
+        ui.window(style='mm_root')
+        ui.null()
+
+        ui.frame(style='mm_menu_frame')
+        ui.vbox(style='mm_outer_box')
+
+        inner_open = False
+        
+        for i, e in enumerate(config.main_menu):
+            
+            if len(e) == 3:
+                label, clicked, enabled = e
+                shown = "True"
+            else:
+                label, clicked, enabled, shown = e
+
+            if not eval(shown):
+                continue
+            
+            if i % config.main_menu_per_group == 0:
+                if inner_open:
+                    ui.close()
+
+                ui.hbox(style='mm_inner_box')
+                inner_open = True
+                
+            # This checks to see if clicked is a string. If so, we want clicked
+            # to jump us out of the current context.
+            if isinstance(clicked, basestring):
+                clicked=ui.jumpsoutofcontext(clicked)
+
+            # Create each button.
+            layout.button(label, "mm", enabled=eval(enabled), clicked=clicked)
+
+        if inner_open:
+            ui.close() # inner box
+            
+        ui.close() # outer box
+
+        ui.interact(mouse="mainmenu")
+        
+    return
+            
+    

common/_layout/grouped_navigation.rpym

@@ -0,0 +1,69 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('navigation')
+
+    style.gm_nav_frame = Style(style.menu_frame, help="game menu navigation frame")
+    style.gm_nav_inner_box = Style(style.hbox, help="inner box containing game menu navigation buttons")
+    style.gm_nav_outer_box = Style(style.vbox, help="outer box containing game menu navigation buttons")
+
+    style.gm_nav_button = Style(style.button, help="game menu navigation button")
+    style.gm_nav_button_text = Style(style.button_text, help="game menu navigation button (text)")
+
+    style.gm_nav_button.size_group = "gm_nav_button"
+    
+    style.gm_nav_frame.xalign = 0.5
+    style.gm_nav_frame.ypos = 0.98
+    style.gm_nav_frame.yanchor = 1.0
+
+    style.gm_nav_inner_box.xalign = 0.5
+    
+    config.navigation_per_group = 4
+    
+    def navigation(screen=None):
+
+        # Display the game menu background
+        ui.window(style=style.gm_root[screen])
+        ui.null()
+
+        if screen is None:
+            return
+
+        # Display the navigation frame.
+        ui.frame(style='gm_nav_frame')
+        ui.vbox(focus='gm_nav', style='gm_nav_outer_box')
+
+        box_open = False
+        
+        for i, e in enumerate(config.game_menu):
+
+            if len(e) == 4:
+                 key, label, clicked, enabled = e
+                 shown = "True"
+            else:
+                 key, label, clicked, enabled, shown = e
+
+            if not eval(shown):
+                continue
+            
+            if i % config.navigation_per_group == 0:
+                if box_open:
+                    ui.close()
+                    
+                ui.hbox(style='gm_nav_inner_box')
+                box_open = True
+                
+            layout.button(label,
+                          "gm_nav",
+                          selected=(screen==key),
+                          enabled=eval(enabled),
+                          clicked=clicked)
+
+        if box_open:
+            ui.close() # inner box.
+            
+        ui.close() # outer box.
+
+    layout.navigation = navigation

common/_layout/imagemap_common.rpym

@@ -0,0 +1,127 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+    
+    class _ImageMapper(object):
+
+        def __init__(self, screen, ground, idle, hover, selected_idle, selected_hover, hotspots, navigation=True, variant=None):
+
+            # If the argument is a dict, look up the screen in that dict, and
+            # return the result. Otherwise, just return the result.
+            def maybe_variant(a):
+                if isinstance(a, dict):
+                    if variant in a:
+                        return a[variant]
+                    else:                        
+                        return a[None]
+                return a
+
+            ground = maybe_variant(ground)
+            
+            self.idle = maybe_variant(idle) or ground
+            self.hover = maybe_variant(hover) or self.idle 
+            self.selected_idle = maybe_variant(selected_idle) or self.idle
+            self.selected_hover = maybe_variant(selected_hover) or self.hover
+            
+            self.hotspots = { }
+            for (x1, y1, x2, y2, name) in maybe_variant(hotspots):
+                self.hotspots[name] = (x1, y1, x2, y2)
+
+            self.remaining_hotspots = set(self.hotspots.keys())
+                
+            if navigation:
+
+                # Display the layout navigation only if there are no
+                # game menu buttons defined. 
+                for i in config.game_menu:
+                    if i[1] in self.hotspots:
+                        break
+                else:
+                    layout.navigation(screen)
+
+            ui.fixed(style='imagemap')
+            ui.image(ground)
+
+            if navigation:
+            
+                # Display any navigation buttons that exist.
+                for e in config.game_menu:
+                    screen_ = e[0]
+                    name = e[1]
+                    act = e[2]
+                    enable = e[3]
+
+                    if not eval(enable):
+                        continue
+
+                    self.button(name, act, screen == screen_)
+                
+        def button(self, name, clicked, selected, keymap={}):
+
+            if name not in self.hotspots:
+                return None
+
+            self.remaining_hotspots.discard(name)
+            
+            x1, y1, x2, y2 = self.hotspots[name]
+
+            if clicked is None:
+                return (x1, y1, x2, y2)
+            
+            if selected:
+                idle = self.selected_idle
+                hover = self.selected_hover
+            else:
+                idle = self.idle
+                hover = self.hover
+                
+            ui.imagebutton(
+                LiveCrop((x1, y1, (x2 - x1), (y2 - y1)), idle),
+                LiveCrop((x1, y1, (x2 - x1), (y2 - y1)), hover),
+                xpos=x1,
+                ypos=y1,
+                xanchor=0,
+                yanchor=0,
+                clicked=clicked,
+                focus_mask=True,
+                style='imagemap_button',
+                keymap=keymap,
+                )
+
+            return (x1, y1, x2, y2)
+
+            
+        def bar(self, name, range, value, changed):
+
+            if name not in self.hotspots:
+                return
+
+            self.remaining_hotspots.discard(name)
+
+            x1, y1, x2, y2 = self.hotspots[name]
+
+            ui.bar(
+                range,
+                value,
+                changed=changed,
+                left_gutter=0,
+                right_gutter=0,
+                left_bar=LiveCrop((x1, y1, (x2 - x1), (y2 - y1)), self.selected_idle),
+                right_bar=LiveCrop((x1, y1, (x2 - x1), (y2 - y1)), self.idle),
+                hover_left_bar=LiveCrop((x1, y1, (x2 - x1), (y2 - y1)), self.selected_hover),
+                hover_right_bar=LiveCrop((x1, y1, (x2 - x1), (y2 - y1)), self.hover),
+                bar_resizing=False,
+                xpos=x1,
+                ypos=y1,
+                xmaximum=(x2-x1),
+                ymaximum=(y2-y1),
+                thumb=None,
+                thumb_shadow=None,
+                thumb_offset=0)
+
+        def nothing(self, name):
+            self.remaining_hotspots.discard(name)
+            
+        def close(self):
+            ui.close()

common/_layout/imagemap_load_save.rpym

@@ -0,0 +1,357 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('load_save')
+    renpy.load_module("_layout/imagemap_common")
+    
+    # The ground image.
+    config.load_save_ground = { }
+
+    # The idle image.
+    config.load_save_idle = { }
+
+    # The hover image.
+    config.load_save_hover = { }
+
+    # The selected idle image.
+    config.load_save_selected_idle = { }
+
+    # The selected hover image.
+    config.load_save_selected_hover = { }
+
+    # The hotspots. Each hotspot is defined by a tuple giving:
+    # - The x-coordinate of the left side.
+    # - The y-coordinate of the top side.
+    # - The x-coordinate of the right side.
+    # - The y-coordinate of the bottoms side.
+    # - The name of the button or slider this is equivalent to.
+    config.load_save_hotspots = { }
+    
+    # Define styles
+    style.file_picker_text = Style(style.large_button_text, help="text inside a file picker entry")
+    style.file_picker_empty_slot = Style(style.file_picker_text, help="text inside an empty file picker entry slot")
+    style.file_picker_text_window = Style(style.default, help="a window containing the file picker text.") 
+    style.file_picker_ss_window = Style(style.default, help="a window containing the screenshot.")
+
+    # Should we disable thumbnails?
+    config.disable_thumbnails = False
+    
+    # The default thumbnail to use when no file exists.
+    config.load_save_empty_thumbnail = None
+    
+    # How we format time in a file entry.
+    config.time_format = "%b %d, %H:%M"
+
+    # How we format a file entry.
+    config.file_entry_format = "%(time)s\n%(save_name)s"
+
+    # True if we should prompt before loading a game.
+    _load_prompt = True
+
+    # This is used to store scratch data that's used by the
+    # library, but shouldn't be saved out as part of the savegame.
+    __scratch = object()
+    __scratch.file_picker_page = None
+    __scratch.initialized = False
+    __scratch.per_page = 0
+    __scratch.pages = 0
+    __scratch.has_autosave = False
+    __scratch.has_quicksave = False
+    
+    def _render_savefile(ime, index, name, extra_info, screenshot, mtime, newest, clicked):
+
+        import time
+
+        (x1, y1, x2, y2) = ime.button(
+            "slot_%d" % index, clicked, newest,
+            keymap={ "save_delete" : ui.returns(("unlink", name)) })
+
+        ui.fixed(xpos=x1, ypos=y1, xmaximum=x2-x1, ymaximum=y2-y1)
+        
+        if not config.disable_thumbnails:
+            ui.window(style=style.file_picker_ss_window[index])
+            ui.add(screenshot)
+
+        s = name + ". " + config.file_entry_format % dict(
+            time=time.strftime(config.time_format,
+                               time.localtime(mtime)),
+            save_name=extra_info)
+
+        ui.window(style=style.file_picker_text_window[index])
+        ui.text(s, style=style.file_picker_text[index])
+
+        ui.close()
+        
+    def _render_new_slot(ime, index, name, clicked):
+
+        (x1, y1, x2, y2) = ime.button("slot_%d" % index, clicked, False)
+        
+        ui.fixed(xpos=x1, ypos=y1, xmaximum=x2-x1, ymaximum=y2-y1)
+
+        if not config.disable_thumbnails:
+
+            if config.load_save_empty_thumbnail:
+                ui.window(style=style.file_picker_ss_window[index])
+                ui.add(config.load_save_empty_thumbnail)
+        
+        ui.window(style=style.file_picker_text_window[index])
+        ui.text(name + ". " + _(u"Empty Slot.") + "\n", style=style.file_picker_empty_slot[index])
+
+        ui.close()
+
+
+    # This function is given a page, and should map it to the names
+    # of the files on that page.
+    def _file_picker_page_files(page):
+
+        per_page = __scratch.per_page
+        rv = [ ]
+
+        if __scratch.has_autosave:
+            if page == 0:
+                for i in range(1, per_page + 1):
+                    rv.append(("auto-" + str(i), _(u"a") + str(i), True))
+
+                return rv
+            else:
+                page -= 1
+
+        if __scratch.has_quicksave:
+            if page == 0:
+                for i in range(1, per_page + 1):
+                    rv.append(("quick-" + str(i), _(u"q") + str(i), True))
+
+                return rv
+            else:
+                page -= 1
+
+        for i in range(per_page * page + 1, per_page * page + 1 + per_page):
+            rv.append(("%d" % i, "%d" % i, False))
+
+        return rv
+
+    # Given a filename, returns the page that filename is on. 
+    def _file_picker_file_page(filename):
+
+        per_page = __scratch.per_page
+
+        base = 0
+
+        if __scratch.has_autosave:
+            if filename.startswith("auto-"):
+                return base
+            else:
+                base += 1
+
+        if __scratch.has_quicksave:
+            if filename.startswith("quick-"):
+                return base
+            else:
+                base += 1
+
+        return base + int((int(filename) - 1) / per_page)
+
+    # Processes a screenshot.
+    def _file_picker_process_screenshot(s):
+        return s
+
+    # Initialize the scratch information.
+    def _file_picker_init():
+
+        hotspots = set()
+
+        if isinstance(config.load_save_hotspots, dict):
+            for d in config.load_save_hotspots.values():
+                for (x1, y1, x2, y2, name) in d:
+                    hotspots.add(name)
+        else:
+            for (x1, y1, x2, y2, name) in config.load_save_hotspots:
+                hotspots.add(name)
+
+        __scratch.has_autosave = ("page_auto" in hotspots)
+        __scratch.has_quicksave = ("page_quick" in hotspots)
+
+        __scratch.per_page = 0
+
+        while ("slot_%d" % __scratch.per_page) in hotspots:
+            __scratch.per_page += 1
+
+        __scratch.pages = 1
+            
+        while ("page_%d" % __scratch.pages) in hotspots:
+            __scratch.pages += 1
+
+        __scratch.pages -= 1
+
+    def _file_picker_pages():
+
+        rv = [ ]
+
+        if config.has_autosave:
+            rv.append("page_auto")
+
+        if config.has_quicksave:
+            rv.append("page_quick")
+
+        for i in range(1, __scratch.pages + 1):
+            rv.append("page_%d" % i)
+
+        return rv
+           
+    
+    # This displays a file picker that can chose a save file from
+    # the list of save files.
+    def _file_picker(screen, save):
+
+        if not __scratch.initialized:
+            __scratch.initialized = True
+            _file_picker_init()
+        
+        # The number of slots in a page.
+        file_page_length = __scratch.per_page
+
+        update = True
+        
+        while True:
+
+            if update:
+                
+                update = False
+                
+                saved_games = renpy.list_saved_games(regexp=r'(auto-|quick-)?[0-9]+')
+
+                newest = None
+                newest_mtime = None
+                save_info = { }
+
+                for fn, extra_info, screenshot, mtime in saved_games:
+                    screenshot = _file_picker_process_screenshot(screenshot)
+                    save_info[fn] = (extra_info, screenshot, mtime)
+
+                    if not fn.startswith("auto-") and mtime > newest_mtime:
+                        newest = fn
+                        newest_mtime = mtime
+
+                # The index of the first entry in the page.
+                fpp = __scratch.file_picker_page
+
+                if fpp is None:
+
+                    if newest:
+                        fpp = _file_picker_file_page(newest)
+                    else:
+                        fpp = _file_picker_file_page("1")
+
+
+            if fpp < 0:
+                fpp = 0
+
+            __scratch.file_picker_page = fpp
+
+            ime = _ImageMapper(
+                screen,
+                config.load_save_ground,
+                config.load_save_idle,
+                config.load_save_hover,
+                config.load_save_selected_idle,
+                config.load_save_selected_hover,
+                config.load_save_hotspots,
+                variant=screen)
+                
+
+            def tb(enabled, label, clicked, selected):
+
+                if not enabled:
+                    return
+
+                ime.button(label, clicked, selected)
+
+            # Previous
+            tb(fpp > 0, 'previous', ui.returns(("fppdelta", -1)), selected=False)
+
+            # Quick Access
+            for i, name in enumerate(_file_picker_pages()):
+                tb(True, name, ui.returns(("fppset", i)), fpp == i)
+
+            # Next
+            tb(True, 'next', ui.returns(("fppdelta", +1)), False)
+
+            # This draws a single slot.
+            def entry(name, filename, offset, ro):
+                clicked = ui.returns(("return", filename))
+                
+                if filename not in save_info:
+                    if (not save) or ro:
+                        clicked = None
+
+                    _render_new_slot(ime, offset, name, clicked)
+
+                else:
+                    if save and ro:
+                        clicked = None
+
+                    extra_info, screenshot, mtime = save_info[filename]
+                    _render_savefile(ime,
+                                     offset,
+                                     name,
+                                     extra_info,
+                                     screenshot,
+                                     mtime,
+                                     newest == filename,
+                                     clicked)
+
+            for i, (filename, name, ro) in enumerate(_file_picker_page_files(fpp)):
+                entry(name, filename, i, ro)
+
+            ime.close()
+                
+            result = ui.interact(mouse="gamemenu")
+            type, value = result
+
+            if type == "unlink":
+                if layout.yesno_prompt(screen, layout.DELETE_SAVE):
+                    renpy.unlink_save(value)
+                    update = True
+
+            if type == "return":
+                return value
+
+            if type == "fppdelta":
+                fpp += value
+
+            if type == "fppset":
+                fpp = value
+
+
+label save_screen:
+
+    python hide:
+        while True:
+            fn = _file_picker("save", True)
+
+            if renpy.can_load(fn):
+                if not layout.yesno_prompt("save", layout.OVERWRITE_SAVE):
+                    continue
+
+            renpy.save(fn, extra_info=store.save_name)
+
+
+label load_screen:
+
+    python hide:
+        while True:
+            fn = _file_picker("load", False)
+            
+            if _load_prompt:
+                if not layout.yesno_prompt("load",  layout.LOADING):
+                    continue
+
+            renpy.load(fn)
+                        
+init python hide:
+    def auto_save_extra_info():
+        return save_name
+    config.auto_save_extra_info = auto_save_extra_info
+    

common/_layout/imagemap_main_menu.rpym

@@ -0,0 +1,80 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('main_menu')
+    renpy.load_module("_layout/imagemap_common")
+
+    # The ground image.
+    config.main_menu_ground = { }
+
+    # The selected/hover image.
+    config.main_menu_selected = { }
+
+    # The idle image.
+    config.main_menu_idle = { }
+    
+    # The hotspots. Each hotspot is defined by a tuple giving:
+    # - The x-coordinate of the left side.
+    # - The y-coordinate of the top side.
+    # - The x-coordinate of the right side.
+    # - The y-coordinate of the bottoms side.
+    # - Either the (untranslated) name of the main menu button this hotspot
+    #   is equivalent to, or, a label in the program to jump to when this
+    #   hotspot is clicked.
+    config.main_menu_hotspots = { }
+
+    # This can be set from user code to define the main menu variant to use.
+    _main_menu_variant = None
+    
+label main_menu_screen:
+
+    python hide:
+        
+        # Ignore right-click while at the main menu.
+        ui.keymap(game_menu=ui.returns(None))
+        
+        # Show the background.
+        ui.window(style='mm_root')
+        ui.null()
+
+        ime = _ImageMapper(
+            None,
+            config.main_menu_ground,
+            config.main_menu_idle,
+            config.main_menu_selected,
+            config.main_menu_idle,
+            config.main_menu_selected,
+            config.main_menu_hotspots,
+            navigation=False,
+            variant=_main_menu_variant)
+            
+        for e in config.main_menu:
+            if len(e) == 4:
+                name, act, enabled, shown = e
+            else:
+                name, act, enabled = e
+                shown = "True"
+                
+            if not eval(shown):
+                ime.nothing(name)
+
+            if not eval(enabled):
+                act = None
+
+            if isinstance(act, basestring):
+                act = ui.jumpsoutofcontext(act)
+                
+            ime.button(name, act, False)
+
+        for i in list(ime.remaining_hotspots):
+            ime.button(i, ui.jumpsoutofcontext(i), None)
+
+        ime.close()
+        ui.interact(mouse='mainmenu')
+                    
+    jump main_menu_screen
+            
+            
+    

common/_layout/imagemap_navigation.rpym

@@ -0,0 +1,85 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('navigation')
+    
+    # The ground image.
+    config.navigation_ground = None
+
+    # The idle image.
+    config.navigation_idle = None
+
+    # The hover image.
+    config.navigation_hover = None
+
+    # The selected idle image.
+    config.navigation_selected_idle = None
+
+    # The selected hover image.
+    config.navigation_selected_hover = None
+
+    # The hotspots. Each hotspot is defined by a tuple giving:
+    # - The x-coordinate of the left side.
+    # - The y-coordinate of the top side.
+    # - The x-coordinate of the right side.
+    # - The y-coordinate of the bottoms side.
+    # - The name of the game menu button this is equivalent to.
+    config.navigation_hotspots = None
+
+    def _navigation(screen=None):
+
+        # Display the game menu background
+        ui.window(style=style.gm_root[screen])
+        ui.null()
+
+        if screen is None:
+            return
+
+        # A map from button name to game menu information.
+        gm = dict()
+        
+        for e in config.game_menu:
+            screen_ = e[0]
+            name_ = e[1]
+            act = e[2]
+            enable = e[3]
+
+            gm[name_] = (screen_, act, enable)
+
+        ui.fixed(style='imagemap')
+        ui.image(config.navigation_ground)
+            
+        for (x0, y0, x1, y1, name) in config.navigation_hotspots:
+
+            if name not in gm:
+                raise Exception("%r was used in a game menu hotspot, but isn't the name of a game menu button." % name)
+
+            screen_, act, enable = gm[name]
+
+            if not eval(enable):
+                continue
+            
+            if screen_ == screen:
+                idle = config.navigation_selected_idle
+                hover = config.navigation_selected_hover
+            else:
+                idle = config.navigation_idle
+                hover = config.navigation_hover
+            
+            ui.imagebutton(
+                LiveCrop((x0, y0, x1-x0, y1-y0), idle),
+                LiveCrop((x0, y0, x1-x0, y1-y0), hover),
+                clicked=act,
+                style='imagemap_button',
+                xpos=x0,
+                ypos=y0,
+                xanchor=0,
+                yanchor=0,
+                focus_mask=True,
+                )
+
+        ui.close()
+
+    layout.navigation = _navigation

common/_layout/imagemap_preferences.rpym

@@ -0,0 +1,144 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('preferences')
+    renpy.load_module("_layout/imagemap_common")
+    
+    # The ground image.
+    config.preferences_ground = None
+
+    # The idle image.
+    config.preferences_idle = None
+
+    # The hover image.
+    config.preferences_hover = None
+
+    # The selected idle image.
+    config.preferences_selected_idle = None
+
+    # The selected hover image.
+    config.preferences_selected_hover = None
+
+    # The hotspots. Each hotspot is defined by a tuple giving:
+    # - The x-coordinate of the left side.
+    # - The y-coordinate of the top side.
+    # - The x-coordinate of the right side.
+    # - The y-coordinate of the bottoms side.
+    # - The name of the button or slider this is equivalent to.
+    config.preferences_hotspots = None
+
+    config.sample_sound = None
+    config.sample_voice = None
+    config.always_has_joystick = False
+
+    def __set(base, field, value):
+        setattr(base, field, value)
+        return True
+
+    __curried_set = renpy.curry(__set)
+
+
+    def __show_preferences():
+
+        ime = _ImageMapper(
+            "preferences",
+            config.preferences_ground,
+            config.preferences_idle,
+            config.preferences_hover,
+            config.preferences_selected_idle,
+            config.preferences_selected_hover,
+            config.preferences_hotspots)
+
+        def pref(name, pref, value):
+            ime.button(
+                name,
+                __curried_set(_preferences, pref, value),
+                getattr(_preferences, pref) == value) 
+            
+        pref("Window", "fullscreen", False)
+        pref("Fullscreen", "fullscreen", True)
+
+        pref("All", "transitions", 2)
+        pref("Some", "transitions", 1)
+        pref("None", "transitions", 0)
+
+        pref("Seen Messages", "skip_unseen", False)
+        pref("All Messages", "skip_unseen", True)
+
+        if not main_menu:
+            ime.button("Begin Skipping", ui.jumps("_return_skipping"), False)
+            
+        pref("Stop Skipping", "skip_after_choices", False)
+        pref("Keep Skipping", "skip_after_choices", True)
+
+        if renpy.display.joystick.enabled or config.always_has_joystick:
+            ime.button("Joystick", ui.jumps("joystick_preferences_screen"), False)
+
+        def play_sound():
+            renpy.sound.play(config.sample_sound)
+
+        ime.button("Sound Test", play_sound, False)
+
+        def play_voice():
+            renpy.sound.play(config.sample_sound, channel=2)
+
+        ime.button("Voice Test", play_voice, False)
+
+        v = _preferences.text_cps
+        if v == 0:
+            v = 150
+        else:
+            v = v - 1
+
+        def set_text_cps(v):
+            if v == 150:
+                v = 0
+            else:
+                v = v + 1
+
+            _preferences.text_cps = v
+
+        ime.bar("Text Speed", 150, v, set_text_cps)
+        
+        v = _preferences.afm_time
+        if v == 0:
+            v = 40
+        else:
+            v = v - 1
+
+        def set_afm_time(v):
+            if v == 40:
+                v = 0
+            else:
+                v = v + 1
+
+            _preferences.afm_time = v
+                
+        ime.bar("Auto-Forward Time", 40, v, set_afm_time)
+
+        def set_music(v):
+            _preferences.set_volume('music', v / 128.0)
+        def set_sound(v):
+            _preferences.set_volume('sfx', v / 128.0)
+        def set_voice(v):
+            _preferences.set_volume('voice', v / 128.0)
+            
+        ime.bar("Music Volume", 128, int(_preferences.get_volume('music') * 128), set_music)
+        ime.bar("Sound Volume", 128, int(_preferences.get_volume('sfx') * 128), set_sound)
+        ime.bar("Voice Volume", 128, int(_preferences.get_volume('voice') * 128), set_voice)
+
+        ime.close()
+        ui.interact(mouse="gamemenu")
+        
+label preferences_screen:
+
+    while True:
+        $ __show_preferences()
+
+
+        
+        
+
+            

common/_layout/imagemap_yesno_prompt.rpym

@@ -0,0 +1,53 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python hide:
+
+    layout.provides('yesno_prompt')
+
+    renpy.load_module("_layout/imagemap_common")
+    
+    # Define styles
+    style.yesno_prompt = Style(style.prompt, help="a yes/no prompt")
+    style.yesno_prompt_text = Style(style.prompt_text, help="a yes/no prompt (text)")
+
+    # Define config variables.
+    config.yesno_prompt_ground = None
+    config.yesno_prompt_idle = None
+    config.yesno_prompt_hover = None
+    config.yesno_prompt_hotspots = None
+
+    config.yesno_prompt_message_images = { }
+
+    
+    def yesno_prompt(screen, message):
+        renpy.transition(config.intra_transition)
+        
+        ime = _ImageMapper(
+            screen,
+            config.yesno_prompt_ground,
+            config.yesno_prompt_idle,
+            config.yesno_prompt_hover,
+            config.yesno_prompt_idle,
+            config.yesno_prompt_hover,
+            config.yesno_prompt_hotspots)
+
+        ime.button("Yes", ui.returns(True), False)
+        ime.button("No", ui.returns(False), False)
+
+        ime.close()
+        
+        default = config.yesno_prompt_message_images.get(layout.ARE_YOU_SURE, None)
+        message_image = config.yesno_prompt_message_images.get(message, default)
+        
+        if message_image:
+            ui.add(message_image)
+        else:
+            layout.prompt(message, "yesno")
+
+        rv = ui.interact(mouse="gamemenu")
+        renpy.transition(config.intra_transition)
+        return rv
+
+    layout.yesno_prompt = yesno_prompt
+    

common/_layout/one_column_preferences.rpym

@@ -0,0 +1,71 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('preferences')
+    
+    # Load the common code.
+    renpy.load_module("_layout/classic_preferences_common")
+
+    # Create styles.
+    style.prefs_column = Style(style.vbox, help="the single preferences column")
+
+    style.prefs_frame.set_parent(style.menu_frame)
+    style.prefs_pref_frame.set_parent(style.default)
+
+    # Adjust styles.
+    style.prefs_frame_box.box_layout = 'vertical'
+
+    style.prefs_frame.xalign = 0.0
+    style.prefs_frame.ypos = 10
+    style.prefs_frame.xmargin = 10
+    
+    style.prefs_slider.xmaximum = 200
+    style.prefs_slider.xalign = 1.0
+
+    style.prefs_volume_slider.xmaximum = 200
+    style.prefs_volume_slider.xalign = 1.0
+    style.prefs_volume_box.xalign = 1.0
+    style.prefs_volume_box.box_layout = 'horizontal'
+
+    style.prefs_pref_box.xfill = True
+    style.prefs_pref_box.box_layout = 'horizontal'
+    style.prefs_pref_choicebox.box_layout = 'horizontal'
+    style.prefs_pref_choicebox.xalign = 1.0
+
+    style.prefs_jump.xfill = True
+    
+    style.prefs_column.box_spacing = 5
+
+    style.soundtest_button.xalign = 1.0
+    style.prefs_jump_button.xalign = 1.0
+    
+    config.translations["Fullscreen 16:9"] = "16:9"
+    config.translations["Fullscreen 16:10"] = "16:10"
+
+    config.soundtest_before_volume = True
+    
+    
+    # Place preferences into groups.
+    config.preferences['prefs_column'] = [
+        config.all_preferences[u'Display'],
+        config.all_preferences[u'Transitions'],
+        config.all_preferences[u'Skip'],
+        config.all_preferences[u'Begin Skipping'],
+        config.all_preferences[u'After Choices'],
+        config.all_preferences[u'Text Speed'],
+        config.all_preferences[u'Auto-Forward Time'],
+        config.all_preferences[u'Music Volume'],
+        config.all_preferences[u'Sound Volume'],
+        config.all_preferences[u'Voice Volume'],
+        config.all_preferences[u'Joystick...'],
+        ]
+
+
+label preferences_screen:
+
+    $ _prefs_screen_run(config.preferences)
+    
+    jump preferences_screen
+    

common/_layout/scrolling_load_save.rpym

@@ -0,0 +1,236 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('load_save')
+    
+    # Store some global information that won't be saved.
+    __session = object()
+    __session.scrollbar_position = None
+
+    # Should we prompt to load?
+    _load_prompt = True
+    
+    # The number of normal save slots.
+    config.load_save_slots = 50
+
+    # The number of autosave slots.
+    config.load_save_auto_slots = 5
+
+    # The number of quicksave slots.
+    config.load_save_quick_slots = 5
+
+    # How we format time in a file entry.
+    config.time_format = "%b %d, %H:%M"
+
+    # How we format a file entry.
+    config.file_entry_format = "%(time)s\n%(save_name)s"
+
+    # Set the default size of thumbnails.
+    config.thumbnail_width = 320
+    config.thumbnail_height = 240
+
+    # The default empty slot thumbnail.
+    config.load_save_empty_thumbnail = None
+    
+    # Styles.
+    style.file_picker_frame = Style(style.frame, help="frame containing the file picker")
+    style.file_picker_side = Style(style.default, help="ui.side containing the file picker and the scrollbars")
+    style.file_picker_viewport = Style(style.viewport, help="viewport containing the file picker entries")
+    style.file_picker_box = Style(style.vbox, help="box containing the file picker entries")
+    style.file_picker_entry = Style(style.large_button, help="the buttons containing information about each file")
+    style.file_picker_text = Style(style.large_button_text, help="the text inside a file picker entry.")
+    style.file_picker_scrollbar = Style(style.vscrollbar, help="the text inside a file picker entry.")
+
+    style.thumbnail_frame = Style(style.frame, help="the style of the frame containing a thumbnail")
+
+
+    # Position things correctly.
+    style.file_picker_frame.xmaximum = 0.5
+    style.file_picker_frame.xmargin = 6
+    style.file_picker_frame.ymargin = 6
+    style.file_picker_frame.yfill = True
+    
+    style.file_picker_entry.xfill = True
+    style.file_picker_entry.yminimum = 58
+    
+    style.thumbnail_frame.ymargin = 6
+    style.thumbnail_frame.xpos = 0.75
+    style.thumbnail_frame.xanchor = 0.5
+    
+    def _file_picker_thumbnail(st, at):
+        if __session.thumbnail:
+            rv = __session.thumbnail
+        elif config.load_save_empty_thumbnail:
+            rv = config.load_save_empty_thumbnail
+        else:
+            rv = Null(width=config.thumbnail_width, height=config.thumbnail_height)
+            
+        return rv, None
+            
+            
+    def _file_picker(screen):
+
+        while True:
+
+            @renpy.curry
+            def hovered(thumbnail):
+                if __session.thumbnail is not thumbnail:
+                    __session.thumbnail = thumbnail
+                    renpy.restart_interaction()
+
+            @renpy.curry
+            def unhovered(thumbnail):
+                if __session.thumbnail is thumbnail:
+                    __session.thumbnail = None
+                    renpy.restart_interaction()
+
+            __session.thumbnail = None
+
+            layout.navigation(screen)
+
+            newest = None
+            newest_time = None
+
+            info = { }
+
+            for name, extra_info, thumbnail, time in renpy.list_saved_games():
+
+                info[name] = (extra_info, thumbnail, time)
+
+                if not name[0] in "0123456789":
+                    continue
+
+                if time > newest_time:
+                    newest = name
+                    newest_time = time
+
+            slots = [ ]
+
+            for i in range(1, config.load_save_slots + 1):
+                slots.append((str(i), str(i)))
+
+            if config.has_quicksave:
+                for i in range(1, config.load_save_quick_slots + 1):
+                    slots.append(('quick-'+ str(i), _(u'q') + str(i)))
+
+            if config.has_autosave:
+                for i in range(1, config.load_save_auto_slots + 1):
+                    slots.append(('auto-' + str(i), _(u'a') + str(i)))
+
+            ui.frame(style=style.file_picker_frame)
+            ui.side(['c', 'r'], style=style.file_picker_side)
+
+
+
+            if __session.scrollbar_position is None:
+                if newest is None:
+                    yoffset = 0
+                else:
+                    yoffset = 1.0 * (int(newest) - 1) / len(slots)
+                value = 0
+
+            else:
+                value = __session.scrollbar_position
+                yoffset = None
+
+            adj = ui.adjustment(value=value)
+            ui.viewport(yadjustment=adj, offsets=(0, yoffset), style=style.file_picker_viewport, mousewheel=True)
+
+            ui.vbox(style=style.file_picker_box, focus=renpy.time.time())
+
+
+            for i, (fn, n) in enumerate(slots):
+
+                clicked = ui.returns(("select", fn))
+
+                if screen == "save" and fn.startswith("auto-"):
+                    clicked = None
+
+                if screen == "load" and fn not in info:
+                    clicked = None
+
+                if fn in info:
+                    extra_info, thumbnail, time = info[fn]
+
+                    ui.button(style=style.file_picker_entry[i],
+                              clicked=clicked,
+                              hovered=hovered(thumbnail),
+                              unhovered=unhovered(thumbnail),
+                              role = "selected_" if (fn == newest) else "",
+                              keymap = { "save_delete" : ui.returns(("unlink", fn)) },
+                              )
+
+                    s = config.file_entry_format % dict(
+                        time=renpy.time.strftime(
+                            config.time_format,
+                            renpy.time.localtime(time)),
+                        save_name=extra_info)
+
+                    ui.text(n + ". " + s, style=style.file_picker_text[i])
+
+                else:
+                    ui.button(style=style.file_picker_entry[i],
+                              clicked=clicked,
+                              role = "selected_" if (fn == newest) else "")
+
+                    ui.text(n + ". " + _(u"Empty Slot."),
+                            style=style.file_picker_text[i])
+
+            ui.close() # vbox/viewport
+
+            ui.bar(adjustment=adj, style=style.file_picker_scrollbar)
+
+            ui.close() # side/window
+
+            # Thumbnail.
+            ui.frame(style=style.thumbnail_frame)
+            ui.add(DynamicDisplayable(_file_picker_thumbnail))
+
+            try:
+                action, arg = ui.interact(mouse="gamemenu")
+            finally:
+                __session.scrollbar_position = adj.value
+                __session.thumbnail = None
+
+            if action == "select":
+                return arg
+
+            elif action == "unlink":
+                if layout.yesno_prompt("save", layout.DELETE_SAVE):
+                    renpy.unlink_save(arg)
+        
+        
+label save_screen:
+
+    python hide:
+        while True:
+            fn = _file_picker("save")
+
+            if renpy.can_load(fn):
+                if not layout.yesno_prompt("save", layout.OVERWRITE_SAVE):
+                    continue
+
+            renpy.save(fn, extra_info=store.save_name)
+
+
+label load_screen:
+
+    python hide:
+
+        while True:
+            fn = _file_picker("load")
+            
+            if _load_prompt:
+                if not layout.yesno_prompt("load",  layout.LOADING):
+                    continue
+
+            renpy.load(fn)
+            
+            
+init python hide:
+    def auto_save_extra_info():
+        return save_name
+    config.auto_save_extra_info = auto_save_extra_info
+    

common/_layout/two_column_preferences.rpym

@@ -0,0 +1,81 @@
+# Copyright 2004-2010 PyTom <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+init python:
+
+    layout.provides('preferences')
+    
+    # Load the common code.
+    renpy.load_module("_layout/classic_preferences_common")
+
+    # Create styles.
+    style.prefs_column = Style(style.vbox, help="columns of preferences")
+    style.prefs_left = Style(style.prefs_column, help="the left preference column")
+    style.prefs_right = Style(style.prefs_column, help="the right preference column")
+
+    style.prefs_left.xmaximum = 520
+    style.prefs_right.xmaximum = 250
+
+    style.prefs_left.xpos = 271
+    style.prefs_left.xanchor = 0.5
+    style.prefs_left.ypos = 10
+    
+    style.prefs_right.xpos = 667
+    style.prefs_right.xanchor = 0.5
+    style.prefs_right.ypos = 10
+
+    style.prefs_slider.xmaximum = 400
+    style.prefs_slider.xalign = 1.0
+
+    style.prefs_volume_slider.xmaximum = 200
+    style.prefs_volume_slider.xalign = 1.0
+    
+    style.prefs_pref_box.xfill = True    
+    style.prefs_pref_choicebox.box_layout = 'horizontal'
+    style.prefs_pref_choicebox.xalign = 1.0
+    style.prefs_volume_box.xalign = 1.0
+
+    style.prefs_jump.xfill = True
+    
+    style.prefs_column.box_spacing = 5
+
+    style.prefs_button.set_parent(style.small_button)
+    style.prefs_button_text.set_parent(style.small_button_text)
+
+    style.soundtest_button.xalign = 1.0
+    style.prefs_jump_button.xalign = 1.0
+    
+    
+    config.sample_voice = "18005551212.ogg"
+    
+    config.translations["Fullscreen 16:9"] = "16:9"
+    config.translations["Fullscreen 16:10"] = "16:10"
+
+    
+    
+    
+    # Place preferences into groups.
+    config.preferences['prefs_left'] = [
+        config.all_preferences[u'Display'],
+        config.all_preferences[u'Transitions'],
+        config.all_preferences[u'Skip'],
+        config.all_preferences[u'Begin Skipping'],
+        config.all_preferences[u'After Choices'],
+        config.all_preferences[u'Text Speed'],
+        config.all_preferences[u'Auto-Forward Time'],
+        ]
+
+    config.preferences['prefs_right'] = [
+        config.all_preferences[u'Music Volume'],
+        config.all_preferences[u'Sound Volume'],
+        config.all_preferences[u'Voice Volume'],
+        config.all_preferences[u'Joystick...'],
+        ]
+
+
+label preferences_screen:
+
+    $ _prefs_screen_run(config.preferences)
+    
+    jump preferences_screen
+    

common/library.rpy

@@ -1,513 +0,0 @@
-# This file consists of renpy functions that aren't expected to be
-# touched by the user too much. We reserve the _ prefix for names
-# defined in the library.
-
-# It's strongly reccomended that you don't edit this file, as future
-# releases of Ren'Py will probably change this file to include more
-# functionality.
-
-# It's also strongly recommended that you leave this file in the
-# game directory, so its functionality is included in your game.
-
-
-
-init -500:
-    python:
-
-        # These are settings that the user can tweak to control the
-        # look of the main menu and the load/save/escape screens.
-
-        # Used to store library settings.
-        library = object()
-
-        # The number of files to show at once.
-        library.file_page_length = 10
-
-        # The number of pages to add quick access buttons for.
-        library.file_quick_access_pages = 5
-
-        # A small amount of padding.
-        library.padding = 2
-
-        # The width of a thumbnail.
-        library.thumbnail_width = 66
-
-        # The height of a thumbnail.
-        library.thumbnail_height = 50
-
-        # The contents of the main menu.
-        library.main_menu = [
-            ( "Start Game", "start" ),
-            ( "Continue Game", "_continue" ),
-            ( "Quit Game", "_quit" ),
-            ]
-
-        # The contents of the game menu choices.
-        library.game_menu = [
-                ( "return", "Return", "_return", 'True'),
-                ( "prefs", "Preferences", "_prefs_screen", 'True' ),
-                ( "save", "Save Game", "_save_screen", '_can_save' ),
-                ( "load", "Load Game", "_load_screen", 'True'),
-                ( "mainmenu", "Main Menu", "_full_restart", 'not _at_main_menu' ),
-                ( "quit", "Quit", "_quit_screen", 'True' ),
-                ]
-
-        # Used to translate strings in the library.
-        library.translations = { }
-
-        # Sound played when entering the library without clicking a
-        # button.
-        library.enter_sound = None
-
-        # Sound played when leaving the library without clicking a
-        # button.
-        library.exit_sound = None
-
-        # True if the skip indicator should be shown.
-        library.skip_indicator = True
-
-        # This is updated to give the user an idea of where a save is
-        # taking place.
-        save_name = ''
-
-        # True if we're at the main menu, false otherwise.
-        _at_main_menu = False
-
-        # True if we can save, false otherwise.
-        _can_save = True
-
-        # The function that's used to translate strings in the game menu.
-        def _(s):
-            """
-            Translates s into another language or something.
-            """
-            
-            if s in library.translations:
-                return library.translations[s]
-            else:
-                return s
-
-        # Called to make a screenshot happen.
-        def _screenshot():
-            renpy.screenshot("screenshot.bmp")
-
-        # Are the windows currently hidden?
-        _windows_hidden = False
-
-        # Hides the windows.
-        def _hide_windows():
-            global _windows_hidden
-
-            if _windows_hidden:
-                return
-
-            try:
-                _windows_hidden = True
-                renpy.interact(renpy.SayBehavior())
-            finally:
-                _windows_hidden = False
-
-
-    # Set up the default keymap.    
-    python hide:
-
-        def invoke_game_menu():
-            renpy.play(library.enter_sound)
-            renpy.call_in_new_context('_game_menu')
-
-        def toggle_skipping():
-            config.skipping = not config.skipping
-
-        # The default keymap.
-        km = renpy.Keymap(
-            rollback = renpy.rollback,
-            screenshot = _screenshot,
-            toggle_fullscreen = renpy.toggle_fullscreen,
-            toggle_music = renpy.toggle_music,
-            toggle_skip = toggle_skipping,
-            game_menu = invoke_game_menu,
-            hide_windows = _hide_windows,
-            )
-
-        config.underlay = [ km ]
-
-
-    # The skip indicator.
-    python hide:
-
-        def skip_indicator():
-
-            if config.allow_skipping and library.skip_indicator:
-
-                ui.conditional("config.skipping")
-                ui.text(_("Skip Mode"), style='skip_indicator')
-
-            return [ ]
-
-        config.overlay_functions.append(skip_indicator)
-
-    return
-        
-# This is the true starting point of the program. Sssh... Don't
-# tell anyone.
-label _start:
-
-    if renpy.has_label("splashscreen") and not _restart:
-        call splashscreen
-
-    jump _main_menu
-
-# This shows the main menu to the user. 
-label _main_menu:    
-
-    # Let the user completely override the main menu.
-    if renpy.has_label("main_menu"):
-        jump main_menu
-
-label _library_main_menu:
-
-    python hide:
-
-        ui.keymousebehavior()
-
-        ui.window(style='mm_root_window')
-        ui.fixed()
-
-        ui.window(style='mm_menu_window')
-        ui.vbox()
-
-        for text, label in library.main_menu:
-            ui.textbutton(text, clicked=ui.returns(label))
-
-        ui.close()
-        ui.close()
-
-        store._result = renpy.interact(suppress_overlay = True,
-                                       suppress_underlay = True)
-
-    # Computed jump to the appropriate label.
-    $ renpy.jump(_result)
-
-    return
-
-# Used to call the game menu. 
-label _continue:
-    $ _can_save = False
-    $ _at_main_menu = True
-    
-    $ renpy.call_in_new_context("_load_menu")
-
-    $ _can_save = True
-    $ _at_main_menu = False
-
-    jump _library_main_menu
-    
-
-##############################################################################
-# 
-# Code for the game menu.
-
-init -500:
-    python:
-
-        # This is used to store scratch data that's used by the
-        # library, but shouldn't be saved out as part of the savegame.
-        _scratch = object()
-
-        
-        # This returns a window containing the game menu navigation
-        # buttons, set up to jump to the appropriate screen sections.
-        def _game_nav(selected):
-
-            ui.keymousebehavior()
-
-            ui.add(renpy.Keymap(game_menu=ui.jumps("_noisy_return")))
-
-            ui.window(style='gm_root_window')
-            ui.fixed()
-
-            ui.window(style='gm_nav_window')
-            ui.vbox()
-            
-            for key, label, target, enabled in library.game_menu:
-                style="gm_nav_button"
-                text_style="gm_nav_button_text"
-                
-                if key == selected:
-                    style = 'gm_nav_selected_button'
-                    text_style = 'gm_nav_selected_button_text'
-
-                clicked = ui.jumps(target)
-
-                if not eval(enabled):
-                    style = 'gm_nav_disabled_button'
-                    text_style = 'gm_nav_disabled_button_text'
-
-                    clicked = lambda : None
-                             
-                    
-                ui.textbutton(_(label), style=style, text_style=text_style,
-                              clicked=clicked)
-
-            ui.close()
-            ui.close()
-                
-        def _game_interact():
-            
-            return renpy.interact(suppress_underlay=True,
-                                  suppress_overlay=True)
-
-
-        def _render_new_slot(name, save):
-            
-            if save:
-                clicked=ui.returns(("return", (name, False)))
-                enable_hover = True
-            else:
-                clicked=None
-                enable_hover = False
-
-            ui.button(style='file_picker_entry',
-                      clicked=clicked,
-                      enable_hover=enable_hover)
-            
-            ui.hbox(padding=library.padding)
-            ui.null(width=library.thumbnail_width,
-                    height=library.thumbnail_height)
-            ui.text(name + ". ", style='file_picker_old')
-            ui.text(_("Empty Slot."), style='file_picker_empty_slot')
-            ui.close()
-                      
-            
-        def _render_savefile(name, info, newest):
-
-            image, extra = info
-
-            ui.button(style='file_picker_entry',
-                      clicked=ui.returns(("return", (name, True))))
-            
-            ui.hbox(padding=library.padding)
-            ui.add(image)
-            
-            if name == newest:
-                ui.text(name + ". ", style='file_picker_new')
-            else:
-                ui.text(name + ". ", style='file_picker_old')
-
-            
-            ui.text(extra, style='file_picker_extra_info')
-
-            ui.close()
-            
-
-        _scratch.file_picker_index = None
-
-        # This displays a file picker that can chose a save file from
-        # the list of save files.
-        def _file_picker(selected, save):
-
-            saves, newest = renpy.saved_games()
-
-            # The index of the first entry in the page.
-            fpi = _scratch.file_picker_index
-
-            if fpi is None:
-                fpi = 0
-
-                if newest:
-                    fpi = int(newest) // library.file_page_length * library.file_page_length
-
-                
-            # The length of a half-page of files.
-            hfpl = library.file_page_length // 2
-
-            while True:
-
-                if fpi < 0:
-                    fpi = 0
-
-                _scratch.file_picker_index = fpi
-
-                # Show Navigation
-                _game_nav(selected)
-                
-                ui.window(style='file_picker_window')
-
-                ui.vbox() # whole thing.
-                
-                ui.hbox(padding=library.padding * 10, style='file_picker_navbox') # nav buttons.
-
-                def tb(cond, label, clicked):
-                    if cond:
-                        style = 'button'
-                        text_style = 'button_text'
-                    else:
-                        style = 'disabled_button'
-                        text_style = 'disabled_button_text'
-
-                    ui.textbutton(label, style=style, text_style=text_style, clicked=clicked)
-
-
-                tb(fpi > 0, _('Previous'), ui.returns(("fpidelta", -1)))
-
-                for i in range(0, library.file_quick_access_pages):
-                    target = i * library.file_page_length
-                    tb(fpi != target, str(i + 1), ui.returns(("fpiset", target)))
-
-                tb(True, _('Next'), ui.returns(("fpidelta", +1)))
-
-                ui.close() # nav buttons.
-
-                def entry(offset):
-                    i = fpi + offset
-
-                    name = str(i + 1)
-
-                    if name not in saves:
-                        _render_new_slot(name, save)
-                    else:
-                        _render_savefile(name, saves[name], newest)
-                    
-
-                ui.hbox() # slots
-
-                ui.vbox()
-                for i in range(0, hfpl):
-                    entry(i)
-                ui.close()
-
-                ui.vbox()
-                for i in range(hfpl, hfpl * 2):
-                    entry(i)
-                ui.close()
-                    
-                ui.close() # slots
-
-                ui.close() # whole thing
-
-                result = _game_interact()
-                type, value = result
-
-                if type == "return":
-                    return value
-
-                if type == "fpidelta":
-                    fpi += value * library.file_page_length
-
-                if type == "fpiset":
-                    fpi = value
-
-                
-        def _yesno_prompt(screen, message):
-
-            _game_nav(screen)
-
-            ui.text(message, style='yesno_prompt')
-            ui.textbutton(_("Yes"), style='yesno_yes', clicked=ui.returns(True))
-            ui.textbutton(_("No"), style='yesno_no', clicked=ui.returns(False))
-
-            return _game_interact()
-
-        def _show_exception(title, message):
-            ui.add(Solid((0, 0, 0, 255)))
-            ui.vbox()
-
-            ui.text(title, color=(255, 128, 128, 255))
-            ui.text("")
-            ui.text(message)
-            ui.text("")
-            ui.text("Please click to continue.")
-
-            ui.close()
-
-            ui.saybehavior()
-
-            ui.interact()
-                     
-
-
-# Factored this all into one place, to make our lives a bit easier.
-label _take_screenshot:
-    $ renpy.take_screenshot((library.thumbnail_width, library.thumbnail_height))
-    return
-
-# Entry points from the game into menu-space.
-label _load_menu:
-    call _take_screenshot
-    jump _load_screen
-
-label _game_menu:
-    call _take_screenshot
-    jump _save_screen
-
-label _confirm_quit:
-    call _take_screenshot
-    jump _quit_screen
-
-# Menu screens.
-label _load_screen:
-
-    python:
-        _fn, _exists = _file_picker("load", False )
-
-    python:
-        renpy.load(_fn)
-
-    jump _load_screen
-
-label _save_screen:
-    $ _fn, _exists = _file_picker("save", True)
-
-    if not _exists or _yesno_prompt("save", _("Are you sure you want to overwrite your save?")):
-        python hide:
-
-            if save_name:
-                full_save_name = "\n" + save_name
-            else:
-                full_save_name = ""
-
-            try:
-                renpy.save(_fn, renpy.time.strftime("%b %d, %H:%M") +
-                           full_save_name)
-
-            except Exception, e:
-
-                if config.debug:
-                    raise
-                
-                message = ( "The error message was:\n\n" +
-                            e.__class__.__name__  + ": " + unicode(e) + "\n\n" +
-                            "You may want to try saving in a different slot, or playing for a while and trying again later.")
-
-                _show_exception(_("Save Failed."), message)
-                
-                
-    jump _save_screen
-
-# Asks the user if he wants to quit.
-label _quit_screen:
-    if _yesno_prompt("quit", _("Are you sure you want to end the game?")):
-        jump _quit
-    else:
-        jump _return
-
-label _quit:
-    $ renpy.quit()
-
-label _full_restart:
-    $ renpy.full_restart()
-
-# Make some noise, then return.
-label _noisy_return:
-    $ renpy.play(library.exit_sound)
-
-# Return to the game.
-label _return:
-    return
-
-# Random nice things to have.
-init:
-    $ centered = Character(None, what_style="centered_text", window_style="centered_window")
-    image text = renpy.ParameterizedText(style="centered_text")
-    
-        

common/preferences.rpy

@@ -1,146 +0,0 @@
-# This file contains the code to implement the Ren'Py preferences
-# screen.
-
-init -450:
-    python:
-
-        # Used to collect the various preferences the system knows
-        # about.
-        library.left_preferences = [ ]
-        library.right_preferences = [ ]
-
-        class _Preference(object):
-            """
-            This is a class that's used to represent a preference that
-            may be shown to the user.
-            """
-
-            def __init__(self, name, field, values):
-                """
-                @param name: The name of this preference. It will be
-                displayed to the user.
-
-                @param variable: The field on the _preferences object
-                that will be assigned the selected value. This field
-                must exist.
-
-                @param values: A list of value name, value, condition
-                triples. The value name is the name of this value that
-                will be shown to the user. The value is the literal
-                python value that will be assigned if this value is
-                selected. The condition is a condition that will be
-                evaluated to determine if this is a legal value. If no
-                conditions are true, this preference will not be
-                displayed to the user. A condition of None is always
-                considered to be True.
-                """
-
-                self.name = name
-                self.field = field
-                self.values = values
-
-            def render_preference(self):
-                values = [ (name, val) for name, val, cond in self.values
-                           if cond is None or renpy.eval(cond) ]
-
-                if not values:
-                    return
-
-                ui.vbox(style='prefs_pref')
-                ui.text(_(self.name), style='prefs_label')
-
-                cur = getattr(_preferences, self.field)
-
-                for name, value in values:
-
-                    style = 'prefs_button'
-                    text_style = 'prefs_button_text'
-
-                    if cur == value:
-                        style = 'prefs_selected_button'
-                        text_style = 'prefs_selected_button_text'
-
-                    def clicked(value=value):
-                        setattr(_preferences, self.field, value)
-                        return True
-
-                    ui.textbutton(_(name),
-                                  style=style,
-                                  text_style=text_style,
-                                  clicked=clicked)
-                    
-                ui.close()
-                    
-
-    python hide:
-
-        # Enablers for some preferences.
-        library.has_music = True
-        library.has_sound = True
-        library.has_transitions = True
-
-
-        p1 = _Preference('Display', 'fullscreen', [
-            ('Window', False, None),
-            ('Fullscreen', True, None),
-            ])
-
-        p2 = _Preference('Music', 'music', [
-            ('Enabled', True, 'library.has_music'),
-            ('Disabled', False, 'library.has_music'),
-            ])
-            
-        p3 = _Preference('Sound Effects', 'sound', [
-            ('Enabled', True, 'library.has_sound'),
-            ('Disabled', False, 'library.has_sound'),
-            ])
-            
-
-        library.left_preferences = [ p1, p2, p3 ]
-
-        p4 = _Preference('TAB and CTRL Skip', 'skip_unseen', [
-            ('Seen Messages', False, 'config.allow_skipping'),
-            ('All Messages', True, 'config.allow_skipping'),
-            ])
-
-        p5 = _Preference('Transitions', 'transitions', [
-            ('All', 2, 'library.has_transitions'),
-            ('Some', 1, 'library.has_transitions and default_transition'),
-            ('None', 0, 'library.has_transitions'),
-            ])
-
-        p6 = _Preference('Text Display', 'fast_text', [
-            ('Fast', True, 'config.annoying_text_cps'),
-            ('Slow', False, 'config.annoying_text_cps'),
-            ])
-            
-
-        library.right_preferences = [ p4, p5, p6 ]
-
-label _prefs_screen:
-
-    python hide:
-
-        _game_nav("prefs")
-
-        ui.vbox(library.padding * 3, style='prefs_left')
-        for i in library.left_preferences:
-            i.render_preference()
-        ui.close()
-                    
-        ui.vbox(library.padding * 3, style='prefs_right')
-        for i in library.right_preferences:
-            i.render_preference()
-        ui.close()
-
-        _game_interact()
-
-    jump _prefs_screen
-    
-        
-
-            
-                        
-
-                         
-                         

common/style.rpy

@@ -1,416 +0,0 @@
-# This file is responsible for creating and defining the default styles
-# used by the system.
-
-# This file should be considered part of the Ren'Py library, and not
-# something that needs to be modified by the user. Instead, just update
-# the appropriate style property in an init: block in your script.
-#
-# For example, to change the default window backgrounds to a
-# transparent dark red, add:
-#
-# init:
-#     $ style.window.background = renpy.Solid((128, 0, 0, 128)
-#
-# to your script. No need to mess around here, it will just make your
-# life harder when a new version of Ren'Py is released.
-
-init -250:
-    python hide:
-
-        style.create('default', None,
-                     'The default style that all styles inherit from.')
-
-        dark_cyan = (0, 192, 255, 255)
-        bright_cyan = (0, 255, 255, 255)
-
-        dark_red = (255, 128, 128, 255)
-        bright_red = (255, 64, 64, 255)
-
-        green = (0, 128, 0, 255)
-
-        # Text properties.
-        style.default.font = "Vera.ttf"
-        style.default.antialias = True
-        style.default.size = 22
-        style.default.color = (255, 255, 255, 255)
-        style.default.drop_shadow = (1, 1)
-        style.default.drop_shadow_color = (0, 0, 0, 128)
-        style.default.minwidth = 0
-        style.default.textalign = 0
-        style.default.text_y_fudge = 0
-        style.default.enable_hover = True
-
-        # Change this if you're not using Vera 22.
-        if renpy.windows():
-            style.default.line_height_fudge = -4
-        else:
-            style.default.line_height_fudge = 0
-            
-        # Window properties.
-        style.default.background = None
-        style.default.xpadding = 0
-        style.default.ypadding = 0
-        style.default.xmargin = 0
-        style.default.ymargin = 0
-        style.default.xfill = False
-        style.default.yfill = False
-        style.default.xminimum = 0 # Includes margins and padding.
-        style.default.yminimum = 0 # Includes margins and padding.
-
-        # Placement properties.
-        style.default.xpos = 0
-        style.default.ypos = 0
-        style.default.xanchor = 'left'
-        style.default.yanchor = 'top'
-
-        # Sound properties.
-        style.default.hover_sound = None
-        style.default.activate_sound = None
-
-        # The base style for the large windows.
-        style.create('window', 'default',
-                     '(window, placement) The base style for the windows that contain dialogue, thoughts, and menus.')
-                     
-        style.window.background = Solid((0, 0, 128, 128))
-        style.window.xpadding = 10
-        style.window.ypadding = 5
-        style.window.xmargin = 10
-        style.window.ymargin = 5
-        style.window.xfill = True
-        style.window.yfill = False
-        style.window.xminimum = 0 # Includes margins and padding.
-        style.window.yminimum = 150 # Includes margins and padding.
-
-        style.window.xpos = 0.5
-        style.window.ypos = 1.0
-        style.window.xanchor = 'center'
-        style.window.yanchor = 'bottom'
-
-        # This style controls the default placement of images on the screen.
-
-        style.create('image_placement', 'default',
-                     'This style is used to control the default placement of images on the screen.')
-
-        style.image_placement.xpos = 0.5
-        style.image_placement.ypos = 1.0
-        style.image_placement.xanchor = 'center'
-        style.image_placement.yanchor = 'bottom'
-
-        # Styles that are used for dialogue.
-
-        style.create('say_label', 'default',
-                     """(text) The style that is used by default for
-                     the label of dialogue. The label is used to
-                     indicate who is saying something.""")
-
-        style.create('say_dialogue', 'default',
-                     """(text) The style that is used by default for
-                     the text of dialogue.""")
-
-        style.create('say_thought', 'default',
-                     """(text) The label that is used by default for
-                     the text of thoughts or narration, when no
-                     speaker is given.""")
-                     
-        style.create('say_window', 'window',
-                     '(window, position) The default style for windows containing dialogue and thoughts.')
-
-
-        # Styles that are used for menus.
-
-        style.create('menu_caption', 'default',
-                     """(text) The style that is used to render a menu
-                     caption.""")
-
-        style.create('menu_choice', 'default',
-                     """(text, hover, sound) The style that is used to render a menu choice.""")
-
-        style.menu_choice.hover_color = (255, 255, 0, 255) # yellow
-        style.menu_choice.idle_color = (0, 255, 255, 255) # cyan
-
-        style.create('menu_window', 'window',
-                     '(window, position) The default style for windows containing a menu.') 
-
-        # Styles that are used by input widgets.
-        style.create('input_text', 'default',
-                     '(text) The style used for the text of an input box.')
-
-        style.input_text.color = (255, 255, 0, 255)
-
-        style.create('input_prompt', 'default',
-                     '(text) The style used for the prompt of an input box.')
-
-        style.create('input_window', 'window',
-                     '(window, position) The style used for the window of an input box.')
-
-        # Styles used by centered.
-        style.create('centered_window', 'default',
-                     '(window) The style that is used for a "window" containing centered text.')
-
-        style.create('centered_text', 'default',
-                     '(text) The style used for centered text.')
-
-        style.centered_window.xpos = 0.5
-        style.centered_window.xanchor = 'center'
-        style.centered_window.xfill = False
-                      
-        style.centered_window.ypos = 0.5
-        style.centered_window.yanchor = 'center'
-        style.centered_window.yfill = False
-
-        style.centered_window.xpadding = 10
-
-        style.centered_text.textalign = 0.5
-        style.centered_text.xpos = 0.5
-        style.centered_text.ypos = 0.5
-        style.centered_text.xanchor = 'center'
-        style.centered_text.yanchor = 'center'
-           
-        # Styles that are used by imagemaps
-        style.create('imagemap', 'image_placement',
-                     '(sound, position) The style that is used for imagemaps.')
-
-        # Style that is used by imagebutttons.
-        style.create('image_button', 'default',
-                     '(window, sound, hover) The default style used for image buttons.')
-
-        style.create('image_button_image', 'default',
-                     'The default style used for images inside image buttons.')
-
-
-        # Styles that are used by all other Buttons.
-        style.create('button', 'default',
-                     '(window, sound, hover) The default style used for buttons in the main and game menus.')
-
-        style.button.xpos = 0.5
-        style.button.xanchor = 'center'
-
-        style.create('button_text', 'default',
-                     '(text, hover) The default style used for the label of a button.')
-
-        style.button_text.xpos = 0.5
-        style.button_text.xanchor = 'center'
-        style.button_text.size = 24
-        style.button_text.color = dark_cyan
-        style.button_text.hover_color = bright_cyan
-        style.button_text.drop_shadow = (2, 2)
-        
-        # Selected button.
-        style.create('selected_button', 'button',
-                     '(window, hover) The style that is used for a selected button (for example, the active screen or a chosen preference).')
-
-        style.create('selected_button_text', 'button_text',
-                     '(text, hover) The style that is used for the label of a selected button.')
-                     
-        style.selected_button_text.color = dark_red
-        style.selected_button_text.hover_color = bright_red
-        
-        # Disabled button.
-
-        style.create('disabled_button', 'button',
-                     '(window, hover) The style that is used for a disabled button.')
-
-        style.disabled_button.hover_sound = None
-        style.disabled_button.activate_sound = None
-
-        style.create('disabled_button_text', 'button_text',
-                     '(text, hover) The style that is used for the label of a disabled button.')
-                     
-        style.disabled_button_text.color = (128, 128, 128, 255)
-        style.disabled_button_text.hover_color = (128, 128, 128, 255)
-
-
-        # Bar.
-        style.create('bar', 'default',
-                     '(bar) The style that is used by default for bars.')
-
-        style.bar.left_bar = Solid(bright_cyan)
-        style.bar.right_bar = Solid((0, 0, 0, 128))
-        style.bar.left_gutter = 0
-        style.bar.right_gutter = 0
-
-        # Styles that are used when laying out the main menu.
-        style.create('mm_root_window', 'default',
-                     '(window) The style used for the root window of the main menu. This is primarily used to set a background for the main menu.')
-
-        style.mm_root_window.background = Solid((0, 0, 0, 255))
-
-        style.create('mm_menu_window', 'default',
-                     '(window, position) A window that contains the choices in the main menu. Change this to change the placement of these choices on the main menu screen.')
-
-        style.mm_menu_window.xpos = 0.9
-        style.mm_menu_window.xanchor = 'right'
-        style.mm_menu_window.ypos = 0.9
-        style.mm_menu_window.yanchor = 'bottom'
-
-        style.create('mm_button', 'button',
-                     '(window, hover) The style that is used on buttons that are part of the main menu.')
-
-        style.create('mm_button_text', 'button_text',
-                     '(text, hover) The style that is used for the labels of buttons that are part of the main menu.')
-
-        # Styles that are used to lay out the game menu.
-
-        style.create('gm_root_window', 'default',
-                     '(window) The style used for the root window of the game menu. This is primarily used to change the background of the game menu.')
-
-        style.gm_root_window.background = Solid((0, 0, 0, 255))
-    
-        style.create('gm_nav_window', 'default',
-                     '(window, position) The style used by a window containing buttons that allow the user to navigate through the different screens of the game menu.')
-
-        style.gm_nav_window.xpos = 0.9
-        style.gm_nav_window.xanchor = 'right'
-        style.gm_nav_window.ypos = 0.95
-        style.gm_nav_window.yanchor = 'bottom'
-
-        
-        style.create('gm_nav_button', 'button',
-                     '(window, hover) The style of an unselected game menu navigation button.')
-
-        style.create('gm_nav_button_text', 'button_text',
-                     '(text, hover) The style of the text of an unselected game menu navigation button.')
-
-        style.create('gm_nav_selected_button', 'selected_button',
-                     '(window, hover) The style of a selected game menu navigation button.')
-
-        style.create('gm_nav_selected_button_text', 'selected_button_text',
-                     '(text, hover) The style of the text of a selected game menu navigation button.')
-        
-        style.create('gm_nav_disabled_button', 'disabled_button',
-                     '(window, hover) The style of a disabled game menu navigation button.')
-
-        style.create('gm_nav_disabled_button_text', 'disabled_button_text',
-                     '(text, hover) The style of the text of a disabled game menu navigation button.')
-        
-
-        style.create('file_picker_window', 'default',
-                     '(window, position) A window containing the file picker that is used to choose slots for loading and saving.')
-
-        style.file_picker_window.xpos = 0
-        style.file_picker_window.xanchor = 'left'
-        style.file_picker_window.ypos = 0
-        style.file_picker_window.yanchor = 'top'
-
-
-        style.create('file_picker_navbox', 'default',
-                     '(position) The position of the naviation (next/previous) buttons in the file picker.')
-
-        style.file_picker_navbox.xmargin = 10
-        
-        style.create('file_picker_image', 'default',
-                     '(position) The position of the image in each file picker entry.')
-
-        style.file_picker_image.xminimum = 280
-
-        style.create('file_picker_entry', 'button',
-                     '(window, hover) The style that is used for each of the slots in the file picker.')
-
-        style.file_picker_entry.xpadding = 5
-        style.file_picker_entry.ypadding = 2
-        style.file_picker_entry.xmargin = 10
-        style.file_picker_entry.xminimum = 400
-        style.file_picker_entry.ymargin = 2
-        
-        style.file_picker_entry.idle_background = Solid((255, 255, 255, 255))
-        style.file_picker_entry.hover_background = Solid((255, 255, 192, 255))
-
-        style.create('file_picker_text', 'default',
-                     '(text) A base style for all text that is displayed in the file picker.')
-        
-        style.file_picker_text.size = 18
-        style.file_picker_text.idle_color = dark_cyan
-        style.file_picker_text.hover_color = bright_cyan
-
-        style.create('file_picker_new', 'file_picker_text',
-                     '(text) The style that is applied to the new indicator in the file picker.')
-
-        style.create('file_picker_old', 'file_picker_text',
-                     '(text) The style that is applied to the old indicator in the file pciker.')
-
-        style.file_picker_new.hover_color = bright_red
-        style.file_picker_new.idle_color = dark_red
-        style.file_picker_new.minwidth = 30
-        style.file_picker_old.minwidth = 30
-
-        style.create('file_picker_extra_info', 'file_picker_text',
-                     '(text) The style that is applied to extra info in the file picker. The extra info is the save time, and the save_name if one exists.')
-
-        style.create('file_picker_empty_slot', 'file_picker_text',
-                     '(text) The style that is used for the empty slot indicator in the file picker.')
-
-        style.create('yesno_prompt', 'default',
-                     '(text, position) The style used for the prompt in a yes/no dialog.')
-
-        style.yesno_prompt.xpos = 0.5
-        style.yesno_prompt.xanchor = 'center'
-
-        style.yesno_prompt.ypos = 0.25
-        style.yesno_prompt.yanchor = 'center'
-
-        style.yesno_prompt.color = green
-
-        style.create('yesno_yes', 'button',
-                     '(position) The position of the yes button on the screen.')
-
-        style.yesno_yes.xpos = 0.33
-        style.yesno_yes.xanchor = 'center'
-        style.yesno_yes.ypos = 0.33
-        style.yesno_yes.yanchor = 'center'
-
-        style.create('yesno_no', 'button',
-                     '(position) The position of the no button on the screen.')
-
-        style.yesno_no.xpos = 0.66
-        style.yesno_no.xanchor = 'center'
-        style.yesno_no.ypos = 0.33
-        style.yesno_no.yanchor = 'center'
-        
-
-        # Preferences
-        style.create('prefs_label', 'default',
-                     '(text, position) The style that is applied to the label of a block of preferences.')
-
-        style.prefs_label.xpos = 0.5
-        style.prefs_label.xanchor = "center"
-        style.prefs_label.color = green
-
-        style.create('prefs_pref', 'default',
-                     '(position) The position of the box containing an individual preference.')
-
-        style.prefs_pref.xpos = 0.5
-        style.prefs_pref.xanchor = 'center'
-
-        style.create('prefs_left', 'default',
-                     '(position) The position of the left column of preferences.')
-
-        style.prefs_left.xpos = 0.25
-        style.prefs_left.xanchor = "center"
-        style.prefs_left.ypos = 0.05
-        style.prefs_left.yalign = "top"
-
-        style.create('prefs_right', 'default',
-                     '(position) The position of the right column of preferences.')
-
-        style.prefs_right.xpos = 0.75
-        style.prefs_right.xanchor = "center"
-        style.prefs_right.ypos = 0.05
-        style.prefs_right.yalign = "top"
-        
-        style.create('prefs_button', 'button',
-                     '(window, hover) The style of an unselected preferences button.')
-
-        style.create('prefs_button_text', 'button_text',
-                     '(text, hover) The style of the text of an unselected preferences button.')
-
-        style.create('prefs_selected_button', 'selected_button',
-                     '(window, hover) The style of a selected preferences button.')
-
-        style.create('prefs_selected_button_text', 'selected_button_text',
-                     '(text, hover) The style of the text of a selected preferences button.')
-
-        style.create('skip_indicator', 'default',
-                     '(text, position) The style of the text that is used to indicate that skipping is in progress.')
-
-        style.skip_indicator.xpos = 10
-        style.skip_indicator.ypos = 10

console.exe

@@ -0,0 +1 @@
+dist/console.exe

demo/script.rpy

@@ -1,207 +0,0 @@
-init:
-    # Set up the size of the screen.
-    $ config.screen_width = 800
-    $ config.screen_height = 600
-
-    # Positions of things on the screen.
-    $ left = Position(xpos=0.0, xanchor='left')
-    $ right = Position(xpos=1.0, xanchor='right')
-    $ center = Position()
-
-    # Backgrounds.
-    image whitehouse = Image("whitehouse.jpg")
-
-    # Character pictures.
-    image eileen happy = Image("9a_happy.png")
-    image eileen vhappy = Image("9a_vhappy.png")
-    image eileen concerned = Image("9a_concerned.png")
-
-    # Character objects.
-    $ e = Character('Eileen', color=(200, 255, 200, 255))
-
-
-# The actual game starts here.
-label start:
-
-    $ renpy.music_start('sun-flower-slow-drag.mid')
-    
-    scene whitehouse
-    show eileen vhappy
-
-    "Girl" "Welcome to Ren'Py 4!"
-
-    show eileen happy
-
-    "Girl" "And welcome to American Bishoujo's former southern base,
-            just outside of Washington, D.C."
-
-    show eileen happy at left
-
-    "Girl" "This isn't the view from our former base, but it'll do for
-            this demo."
-
-    show eileen happy
-
-    "Girl" "My name is Eileen, and while I plan to star in my own game
-            one day, for now I'm helping to introduce you to Ren'Py."
-
-    e "Ren'Py is an engine that makes it easy to write visual novel
-       games, by taking care of much of the hard work of writing a
-       game."
-
-    e "For example, displaying a line of dialogue is a single
-       statement. So is displaying a thought or narration."
-
-    "I understand."
-
-    e "Dialogue is easy to write. Just put a string on a line by
-       itself, or to the right of an object name or label string."
-
-    e "Since dialogue makes up the bulk of these games, we thought it
-       should be easy to write."
-
-    e "Ren'Py can also display menus that let you alter the flow of
-       the story."
-
-    menu:
-        "Why don't you try a menu out by picking a number?"
-
-        "1":
-            show eileen concerned
-            e "You picked one. I don't like odd numbers."
-
-        "2":
-            show eileen vhappy
-            e "You picked two. Even numbers are lucky!"
-
-    show eileen happy
-
-    e "There are a number of statements that control what's displayed
-       on the screen. The image statement is used to introduce
-       images with names."
-
-    scene
-
-    e "The scene statement can clear the screen..."
-
-    scene whitehouse
-
-    e "... or it can clear the screen and then show a background."
-
-    show eileen happy
-
-    e "The show statement is used to show pictures."
-
-    e "When the show statement is used on an image with the same first
-       name (called a tag) as one already shown, it replaces that picture."
-
-    show eileen vhappy
-
-    e "This makes it easy for characters to change emotions."
-
-    hide eileen
-
-    e "The hide statement hides an image."
-
-    show eileen happy at center
-
-    e "A new feature in Ren'Py 4 is the at clause on images, which
-       lets you say where you want to show the image at. I can go
-       from the center of the screen..."
-
-    show eileen happy at left
-
-    e "... to the left of the screen ..."
-
-    show eileen happy at right
-
-    e "... to the right of the screen ..."
-
-    show eileen happy
-
-    e "... and back to the center."
-    
-    e "Ren'Py supports a variety of control statements, such as jump,
-       call, return, if, and while statements."
-
-    e "Rather than bore you with the details, i'll just tell you to
-       check grab the Ren'Py tutorial from http://www.bishoujo.us/renpy/."
-
-    e "That's just about it for writing scripts. Let me show you some
-       of the new engine features."
-
-    e "The first feature I can show off is the ability to go
-       full-screen. Hit the 'f' key to try it out, and hit 'f'
-       again to go back to a window."
-
-    show eileen vhappy
-
-    e "The next feature, rollback, is really neat."
-
-    show eileen happy
-
-    menu:
-        "Would you like to see it?"
-
-        "Yes.":
-            pass
-
-        "No.":
-            jump after_rollback
-
-    e "Rollback lets you play the game backwards."
-
-    e "It lets you go back and reread a line of dialogue you missed,
-       or even to go back to a menu and make a different choice if you
-       made a mistake."
-
-    e "We do limit the number of steps someone can rollback."
-
-    e "Try it out now, by hitting page up until you get back to the
-       menu, and then choose 'No' instead of 'Yes'."
-
-    show eileen concerned
-
-    e "Well, try it."
-
-    e "You want to hit page up."
-
-    e "Well, whatever, your loss. Moving on."
-    
-
-label after_rollback:
-
-    show eileen happy
-
-    e "Another new feature works only on Windows. If a game crashes,
-       a notepad is brought up showing the crash message, to help
-       you debug what went wrong."
-
-    e "The biggest new feature, though, is reasonable
-       documentation, which you can read at http://www.bishoujo.us/renpy/."
-
-    show eileen concerned
-
-    e "Since this is just a preview release, there are still a few
-       things missing."
-
-    e "For example, there's no support for loading or saving."
-
-    e "We also left out music and animations."
-
-    show eileen happy
-
-    e "Don't worry, though. Those will be coming in the final release,
-       which is due out in a few weeks."
-
-    e "You can begin making your own game by editing game/script.rpy. That's
-       the script for the game you're playing now."
-
-    e "After you make a change, you have to re-run the game to see
-       the change take effect."
-
-    show eileen vhappy
-
-    e "Good luck making your own games!"
-
-    return

demo2/script.rpy

@@ -1,738 +0,0 @@
-# This script, but not the artwork associated with it, is in the
-# public domain. Feel free to use it as the basis for your own
-# game.
-
-# If you're trying to understand this script, I recommend skipping
-# down to the line beginning with 'label start:', at least on your
-# first read-through.
-
-# This init block runs first, and sets up all sorts of things that
-# are used by the rest of the game. Variables that are set in init
-# blocks are _not_ saved, unless they are changed later on in the
-# program.
-
-init:
-
-    # Set up the size of the screen, and the window title.
-    $ config.screen_width = 800
-    $ config.screen_height = 600
-    $ config.window_title = "The Ren'Py Demo Game"
-
-    # Change some styles, to add images in the background of
-    # the menus and windows.
-    $ style.mm_root_window.background = Image("mainmenu.jpg")
-    $ style.gm_root_window.background = Image("gamemenu.jpg")
-    $ style.window.background = Frame("frame.png", 125, 25)
-
-    # Interface sounds, just for the heck of it.
-    $ style.button.activate_sound = 'click.wav'
-    $ style.imagemap.activate_sound = 'click.wav'
-    $ library.enter_sound = 'click.wav'
-    $ library.exit_sound = 'click.wav'
-
-    # These are positions that can be used inside at clauses. We set
-    # them up here so that they can be used throughout the program.
-    $ left = Position(xpos=0.0, xanchor='left')
-    $ right = Position(xpos=1.0, xanchor='right')
-    $ center = Position()
-
-    # Likewise, we set up some transitions that we can use in with
-    # clauses and statements.
-    $ fade = Fade(.5, 0, .5) # Fade to black and back.
-    $ dissolve = Dissolve(0.5)
-
-    # Now, we declare the images that are used in the program.
-
-    # Backgrounds.
-    image carillon = Image("carillon.jpg")
-    image whitehouse = Image("whitehouse.jpg")
-    image washington = Image("washington.jpg")
-    image black = Solid((0, 0, 0, 255))
-
-    # Character pictures.
-    image eileen happy = Image("9a_happy.png")
-    image eileen vhappy = Image("9a_vhappy.png")
-    image eileen concerned = Image("9a_concerned.png")
-
-    # Finally, the character object. This object lets us have the
-    # character say dialogue without us having to repeatedly type
-    # her name. It also lets us change the color of her name.
-    
-    # Character objects.
-    $ e = Character('Eileen', color=(200, 255, 200, 255))
-
-# The splashscreen is called, if it exists, before the main menu is
-# shown the first time. It is not called if the game has restarted.
-
-# We'll comment it out for now.
-#
-# label splashscreen:
-#     scene black
-#     show text "American Bishoujo Presents..." with fade
-#     $ renpy.pause(1.0)
-#     hide text with fade
-#
-#     return
-
-# The start label marks the place where the main menu jumps to to
-# begin the actual game.
-
-label start:
-
-    # The save_name variable sets the name of the save game. Like all
-    # variables declared outside of init blocks, this variable is
-    # saved and restored with a save file.
-    $ save_name = "Introduction"
-
-    # This variable is only used by our game. If it's true, it means
-    # that we won the date.
-    $ date = False
-
-
-    # Start some music playing in the background.
-    $ renpy.music_start('sun-flower-slow-drag.mid')
-
-    # Now, set up the first scene. We first fade in our washington
-    # background, and then we dissolve in the image of Eileen on top
-    # of it.
-    scene washington with fade
-    show eileen vhappy with dissolve
-
-    # Display a line of dialogue. In this case, we manually specify
-    # who's saying the line of dialoge.    
-    "Girl" "Hi, and welcome to the Ren'Py 4 demo program."
-
-    # This instantly replaces the very happy picture of Eileen with
-    # one showing her merely happy. It demonstrates how the show
-    # statement lets characters change emotions.
-    show eileen happy
-
-    # Another line of dialogue.
-    "Girl" "My name is Eileen, and while I plan to one day star in a
-            real game, for now I'm here to tell you about Ren'Py."
-
-    # This line used the e character object, which displays Eileen's
-    # name in green. The use of a short name for a character object
-    # lets us save typing when writing the bulk of the dialogue.
-    e "Ren'Py is a language and engine for writing and playing visual
-       novel games."
-
-    e "Our goal is to allow people to be able to write the script for
-       a game, and with very little effort, turn that script into
-       a working game."
-
-    e "I can tell you about the features of Ren'Py games, or how to write
-       your own game. What do you want to know about?"
-
-    # This variable is used to save the choices that have been made in
-    # the main menu.
-    $ seen_set = [ ]
-
-label choices:
-
-    # We change the save name here.
-    $ save_name = "Question Menu"
-
-    # This is the main menu, that lets the user decide what he wants
-    # to hear about.
-    menu:
-
-        # The set menu clause ensures that each menu choice can only
-        # be chosen once.
-        set seen_set
-
-        # This is a menu choice. When chosen, the statements in its
-        # block are executed.
-        "What are some features of Ren'Py games?":
-
-            # We call the features label. The from clause needs to be
-            # here to ensure that save games work, even after we
-            # change the script. It was added automatically.
-            call features from _call_features_1
-
-            # When we're done talking about features, jump back up
-            # to choices.
-            jump choices
-
-        # Another choice. 
-        "How do I write my own games with it?":
-            call writing from _call_writing_1
-            jump choices
-
-        # This choice has a condition associated with it. It is only
-        # displayed if the condition is true (in this case, if we have
-        # selected at least one other choice has been chosen.) 
-        "Where can I find out more?" if seen_set:
-            call find_out_more from _call_find_out_more_1
-            jump choices
-
-        "Why are we in Washington, DC?":
-            call washington from _call_washington_1
-            jump choices
-
-        "I think I've heard enough." if seen_set:
-            jump ending
-
-
-# This is the section on writing games.
-label writing:
-
-    # Change the title of the save games.
-    $ save_name = "Writing Games"
-
-    # We start off with a bunch of dialogue.
-    e "If you want to write a game, I recommend that you read the
-       Ren'Py tutorial, which you can get from our web page,
-       http://www.bishoujo.us/renpy/."
-
-    e "But here, we'll go over some of the basics of writing Ren'Py
-       scripts. It might make sense if you open the source for this
-       game."
-
-    e "The source for this game can be found in the file
-       game/script.rpy."
-
-    e "The goal of Ren'Py is to make writing the game similar to
-       typing up the script on the computer."
-
-    e "For example, a line of dialogue is expressed by putting the
-       character's name next to the dialogue string."
-
-    # A string by itself like this displays without a name associated
-    # with it. So it's useful for dialogue and narration.
-    "I somehow remember that strings by themselves are displayed as
-     thoughts or narration."
-    
-    e "The menu statement makes it easy to create menus."
-
-    e "A number of statements let you control what is shown on the
-       screen."
-
-    # This scene statement has a with clause associated with it. In
-    # this case (based on what is defined in the init clause at the
-    # top of this script), it causes a fade to black, and then back
-    # to the new scene.
-    scene whitehouse with fade
-
-    e "The scene statement clears the scene list, which is the list of
-       things that are shown on the screen."
-
-    # This shows an image, and dissolves it in.
-    show eileen happy with dissolve
-
-    e "The show statement shows another image on the screen."
-
-    # The at clause here, displays the character on the left side of
-    # the screen.
-    show eileen happy at left with dissolve
-
-    e "Images can take at clauses that specify where on the screen
-       they are shown."
-
-    show eileen vhappy at left
-
-    e "Showing a new image with the same first part of the name
-       replaces the image in the scene list."
-
-    hide eileen with dissolve
-
-    e "Finally, the hide statement hides an image, which is useful
-       when a character leaves the scene."
-
-    show eileen happy with dissolve
-
-    e "Don't worry, I'm not going anywhere."
-
-    e "The with statement is used to cause transitions to
-       happen. Transitions like fade..."
-
-    # This statement hides the transient stuff from being included
-    # in the next fade.
-    with None
-
-    # This with statement causes things to fade without changing the
-    # scene.
-    with fade
-
-    e "... or dissolve ..."
-
-    # In this block, the scene statement clears the scene list. So we
-    # have to reshow the eileen happy image, so that it appears that
-    # just the background is dissolving. Sneaky.
-    with None
-    scene washington
-    show eileen happy
-    with dissolve
-
-    e "... are easily invoked."
-
-    e "As of version 4.2, Ren'Py supports image maps, which are like
-       another form of menu. Let's try one."
-
-    # This is an imagemap. It consists of two images, and a list of
-    # hotspots. For each hotspot we give the coordinates of the left,
-    # top, right, and bottom sides, and the value to return if it is
-    # picked.
-
-    $ result = renpy.imagemap("ground.png", "selected.png", [
-        (100, 100, 300, 400, "eileen"),
-        (500, 100, 700, 400, "lucy")
-        ])
-
-    # We've assigned the chosen result from the imagemap to the
-    # result variable. We can use an if statement to vary what
-    # happens based on the user's choice.
-
-    if result == "eileen":
-        show eileen vhappy
-        e "You picked me!"
-
-    elif result == "lucy":
-        show eileen concerned
-        e "It looks like you picked Lucy."
-
-        # Eileen is being a bit possesive here. :-P
-        if date:
-            e "You can forget about Saturday."
-            $ date = False
-
-    show eileen happy
-
-    e "Ren'Py supports music, such as what's playing in the
-       background..."
-
-    # This plays a sound effect.
-    $ renpy.play("18005551212.wav")
-    
-    e "... and sound effects, like the one that just played."
-
-    e "We now provide a series of user-interface functions, that allow
-       the programmer to create fairly complex interfaces."
-
-    e "For example, try the following scheduling and stats screen,
-       which could be used by a stat-based dating simulation."
-
-    $ day_planner()
-    
-    e "Ren'Py also includes a number of control statements, and even
-       lets you include python code."
-
-    e "Rather than go into this here, you can read all about it in the
-       tutorial."
-
-    e "If you want to make changes, you can edit the script for this
-       game by editing game/script.rpy"
-
-    e "When you've made a change, just re-run the game to see your
-       change in action."
-
-    e "Would you like to know about something else?"
-
-    # We return back up to the menu that lets the user pick a topic.
-    return
-
-# This ends the well-commented portion of this script.
-
-label features:
-
-    $ save_name = "Features"
-
-    e "By providing a range of useful features, we let game authors
-       focus on writing their games."
-
-    e "What are some of these features? Well, first of all, we take
-       care of displaying the screen, as well as dialogue and menus."
-
-    e "You can navigate through the game using the keyboard or the
-       mouse. If you've gotten this far, you've probably figured that
-       out already."
-
-    e "If you press 'f', you can toggle fullscreen mode. Pressing 'm'
-       will toggle music on and off."
-
-    e "Right-clicking or pressing escape will bring you to the game
-       menu."
-
-    e "The game menu lets you save or load the game. Ren'Py doesn't
-       limit the number of save slots available. You can create as
-       many slots as you can stand."
-
-    e "The game menu also lets you restart or quit the game. But you
-       wouldn't want to do that, would you?"
-
-    e "Finally, the game menu lets you set up the game
-       preferences. These preferences are saved between games."
-
-    show eileen vhappy
-
-    e "The next feature is really neat."
-
-    show eileen happy
-
-    menu rollback_menu:
-        "Would you like to hear about rollback?"
-        
-        "Yes.":
-            pass
-
-        "No.":
-            jump after_rollback
-
-
-    e "Rollback is a feature that only Ren'Py has. It lets you go back
-       in time in a game."
-
-    e "For example, you can go back to a menu and save or make a
-       different choice."
-
-    e "You can access it by pressing page up or scrolling up on your
-       mouse wheel."
-
-    e "Why don't you try it by going back to the last menu and
-       choosing 'No.' instead of 'Yes.'"
-
-    e "Press page up or scroll up the mouse wheel."
-
-    show eileen concerned
-
-    e "Well, are you going to try it?"
-
-    e "Your loss."
-
-    e "Moving on."
-
-label after_rollback:
-
-    show eileen happy
-    
-    e "Ren'Py gives you a few ways of skipping dialogue. Pressing
-       control quickly skips dialogue you've seen at least once."
-
-    e "Pressing Tab toggles the skipping of dialogue you've seen at
-       least once."
-
-    e "Pressing page down or scrolling the mouse wheel down will let
-       you skip dialogue you've seen this session. This is useful
-       after a rollback."
-
-    e "If you want to try these, you might want to rollback a bit
-       first, so you can skip over something you've seen already."
-
-    e "Finally, Ren'Py has predictive image loading, so you rarely
-       have to wait for a new image to load."
-
-    e "Remember, all these features are built into the engine or
-       standard library. So every game written with Ren'Py has them."
-
-    e "Is there anything else you'd like to know about?"
-    
-    return
-
-
-label find_out_more:
-
-    $ save_name = "Find Out More"
-
-    e "There are a few places you can go to find out more about
-       Ren'Py."
-
-    e "The Ren'Py homepage, http://www.bishoujo.us/renpy/, is probably
-       the best place to start."
-
-    e "There, you can download new versions of Ren'Py, and read the
-       tutorial online."
-
-    e "If you have questions, the best place to ask them is the Ren'Py
-       forum of the Lemmasoft forums."
-
-    e "Just go to http://www.lemmasoft.net/forums/, and click on
-       Ren'Py."
-
-    e "We thank Blue Lemma for hosting our forum."
-
-    e "Finally, feel free to email or IM us if you need help. You can
-       get the addresses to use from http://www.bishoujo.us/renpy/."
-
-    e "We really want people to make their own games with Ren'Py, and
-       if there's anything we can do to help, just tell us."
-
-    e "Is there anything I can help you with now?"
-
-    return
-
-label washington:
-
-    $ save_name = "Washington, DC"
-
-    e "We're in Washington, DC because over Summer 2004 American
-       Bishoujo's home base was just outside of DC."
-
-    scene whitehouse
-    show eileen happy at left
-    with fade
-
-    e "Even though we've moved back to New York, we took a bunch of
-       pictures, and decided to use them."
-
-    show eileen concerned at left
-
-    e "It was easier than drawing new pictures for this demo."
-
-    show eileen happy at left
-    
-    e "Do you have a favorite landmark in or around DC?"
-
-    menu:
-
-        "The White House.":
-
-            e "I was supposed to go on a tour of the West Wing, once."
-
-            show eileen concerned
-
-            e "They wouldn't let us in."
-
-            e "The secret service guy who was supposed to show us
-               around was out of town that day."
-
-            e "Too bad."
-
-        "The National Mall.":
-
-            e "It's always fun to go down to the national mall."
-
-            e "You can visit the monuments, or see one of the
-               museums."
-
-            e "I guess you could run out of things to do after a while
-               but I didn't over the course of a summer."
-            
-        "The Netherlands Carillon.":
-            jump netherlands
-            
-    jump post_netherlands
-
-label netherlands:
-
-    show eileen vhappy at left
-
-    e "You've been to the Netherlands Carillon?"
-
-    scene carillon
-    show eileen vhappy at left
-    with dissolve
-
-    e "It may not be much to look at but the sound of the bells is
-       really neat."
-
-    e "I love going there. Saturdays during the summer, they have
-       these recitals in the park where a guy comes and plays the 
-       bells live."
-
-    e "You can climb to the top and talk to him, if you're not afraid
-       of heights."
-
-    e "Once, I saw a little girl there, maybe three or four years old.
-       The guy played the bumblebee song for here, and he even let her play the last
-       note. It was so cute!"
-
-    e "I haven't been there for so long."
-
-    menu:
-        "Would you like to go there sometime?":
-
-            e "You mean, together?"
-
-            e "Sure, why not. How does next Saturday sound?"
-            
-            e "It's a date."
-
-            $ date = True
-
-        "That sounds nice.":
-
-            show eileen happy at left
-
-            e "Well, it is."
-        
-label post_netherlands:
-
-    scene washington
-    show eileen happy
-    with fade
-
-    e "Anyway, is there anything else you want to know about Ren'Py?"
-
-    return
-
-label ending:
-
-    $ save_name = "Ending"
-
-    e "Well, that's okay."
-
-    e "I hope you'll consider using Ren'Py for your next game
-       project."
-
-    show eileen vhappy
-
-    e "Thanks for viewing this demo!"
-
-    if date:
-        e "And I'll see you on Saturday."
-    
-    scene black with fade
-
-    "Ren'Py and the Ren'Py demo were written by PyTom."
-
-    'The background music is "Sun Flower Slow Drag" by S. Joplin
-     (1868-1917). Thanks to the Mutopia project for making it
-       available.'
-
-    'The author would like to thank everyone who makes original
-     English-language bishoujo games, and the people on the Lemmasoft forums
-     who encouraged him.'
-
-    "We can't wait to see what you do with this. Good luck!"
-       
-    $ renpy.full_restart()
-
-init:
-
-    # This is just some example code to show the ui functions in
-    # action. You probably want to delete this (and the call to
-    # day_planner above) from your game. This code isn't really all
-    # that useful except as an example.
-    
-    python:
-        def day_planner():
-
-            periods = [ 'Morning', 'Afternoon', 'Evening' ]
-            choices = [ 'Study', 'Exercise',
-                        'Eat', 'Drink', 'Be Merry' ]
-
-            plan = { 'Morning' : 'Eat',
-                     'Afternoon' : 'Drink',
-                     'Evening' : 'Be Merry' }
-
-            day = 'March 25th'
-
-            stats = [
-                ('Strength', 100, 10),
-                ('Intelligence', 100, 25),
-                ('Moxie', 100, 100),
-                ('Chutzpah', 100, 75),
-                ]
-
-            editing = None
-
-            def button(text, selected, returns, **properties):
-                style = 'button'
-                style_text = 'button_text'
-
-                if selected:
-                    style='selected_button'
-                    style_text='selected_button_text'
-
-                ui.button(clicked=ui.returns(returns),
-                          style=style, **properties)
-                ui.text(text, style=style_text)
-
-
-            while True:
-
-                # Stats Window
-                ui.window(xpos=0,
-                          ypos=0,
-                          xanchor='left',
-                          yanchor='top',
-                          xfill=True,
-                          yminimum=200,
-                          )
-
-                ui.vbox()
-
-                ui.text('Statistics')
-                ui.null(height=20)
-
-
-                for name, range, value in stats:
-
-                    ui.hbox()
-                    ui.text(name, minwidth=150)
-                    ui.bar(600, 20, range, value, ypos=0.5, yanchor=center)
-                    ui.close()
-
-                ui.close()
-                
-                
-
-            
-                # Period Selection Window.
-                ui.window(xpos=0,
-                          ypos=200,
-                          xanchor='left',
-                          yanchor='top',
-                          xfill=False,
-                          xminimum=300
-                          )
-                
-                ui.vbox(xpos=0.5, xanchor='center')
-                ui.text(day, xpos=0.5, xanchor='center', textalign=0.5)
-                ui.null(height=20)
-                
-                for i in periods:
-                    face = i + ": " + plan[i]
-                    button(face, editing == i, ("edit", i))
-
-                ui.null(height=20)
-                ui.textbutton("Continue", clicked=ui.returns(("done", True)))
-                ui.null(height=20)
-                ui.close()
-
-
-                # Choice window.
-                if editing:
-                    ui.window(xpos=300,
-                              ypos=200,
-                              xanchor='left',
-                              yanchor='top',
-                              xfill=False,
-                              xminimum=500
-                              )
-                
-                    ui.vbox()
-                    ui.text("What will you do in the %s?" % editing.lower())
-                    ui.null(height=20)
-
-                    for i in choices:
-                        button(i, plan[editing] == i, ("set", i),
-                               xpos=0, xanchor='left')
-
-                    ui.close()
-
-                # Window at the bottom.
-                ui.window()
-                ui.vbox()
-                ui.text("To get to the next screen, click the 'Continue' button.")
-                ui.close()
-                
-                type, value = ui.interact()
-
-                if type == "done":
-                    break
-
-                if type == "edit":
-                    editing = value
-
-                if type == "set":
-                    plan[editing] = value
-                    editing = None
-
-
-
-            return plan
-            
-            
-                   
-                        

distribute.py

@@ -1,128 +1,238 @@
-import os.path
-import os
+#!/home/tom/bin/renpython -O
+# Builds a distributions of Ren'Py.
+
 import sys
+import os
+import zipfile
+import tarfile
+import time
+import zlib
+import compileall
+import shutil
 
-def match_times(source, dest):
+zlib.Z_DEFAULT_COMPRESSION = 9
 
-    stat = os.stat(source)
-    os.utime(dest, (stat.st_atime, stat.st_mtime))
+# Gets the data for the given file.
+def data(fn):
+
+    rv = file(fn, "rb").read()
+
+    if fn.startswith("renpy.app"):
+        return rv
+
+    if fn.endswith(".rpy") or fn.endswith(".py") or fn.endswith(".txt"):
+        rv = rv.replace("\n", "\r\n")
+        rv = rv.replace("\r\r\n", "\r\n")
+
+    return rv
     
-def dosify(s):
-    return s.replace("\n", "\r\n")
 
-def copy_file(source, dest, license=""):
+def tarup(filename, prefix, files):
 
-    print source, "->", dest
+    tf = tarfile.open(filename, "w:bz2")
+    tf.dereference = True
 
-    sf = file(source, "rb")
-    df = file(dest, "wb")
+    sys.stdout.write(filename)
+    sys.stdout.flush()
 
-    df.write(license)
+    for fn in files:
+        sys.stdout.write(".")
+        sys.stdout.flush()
+        
+        tf.add(fn, prefix + "/" + fn, False)
 
-    data = sf.read()
-    if dest.endswith(".txt") or dest.endswith(".py") or dest.endswith(".rpy") or dest.endswith(".bat"):
-        data = dosify(data)
+    sys.stdout.write("\n")
+        
+    tf.close()
+    
 
-    df.write(data)
+# Creates a zip file.
+def zipup(filename, prefix, files):
 
-    sf.close()
-    df.close()
+    zf = zipfile.ZipFile(filename, "w")
 
-    match_times(source, dest)
+    sys.stdout.write(filename)
+    sys.stdout.flush()
 
+    for fn in files:
+        sys.stdout.write(".")
+        sys.stdout.flush()
 
-def copy_tree(source, dest, should_copy=lambda fn : True, license=""):
+        zi = zipfile.ZipInfo(prefix + "/" + fn)
 
-    os.makedirs(dest)
+        st = os.stat(fn)
 
-    for dirpath, dirnames, filenames in os.walk(source):
+        zi.date_time = time.gmtime(st.st_mtime)[:6]
+        zi.compress_type = zipfile.ZIP_DEFLATED
+        zi.create_system = 3
+        zi.external_attr = long(st.st_mode) << 16
 
-        if "/saves" in dirpath:
-            continue
+        zf.writestr(zi, data(fn))
+        
+    zf.close()
 
-        if "/CVS" in dirpath:
-            continue
+    sys.stdout.write("\n")
+    sys.stdout.flush()
+    
+    
 
-        reldir = dirpath[len(source):]
-        dstrel = dest + "/" + reldir
+def tree(root):
 
-        for i in dirnames:
-            if i == "CVS":
-                continue
-            
-            os.mkdir(dstrel + "/" + i)
+    rv = [ ]
 
-        for i in filenames:
-            if not should_copy(i):
+    for dirname, dirs, filenames in os.walk(root):
+
+        if "saves" in dirs:
+            dirs.remove("saves")
+
+        if ".svn" in dirs:
+            dirs.remove(".svn")
+        
+        for f in filenames:
+            if f[-1] == '~' or f[0] == '.':
                 continue
 
-            copy_file(dirpath + "/" + i, dstrel + "/" + i, license=license)
-            
+            if f.endswith(".bak") or f.endswith(".pyc"):
+                continue
 
-            
+            if f == "semantic.cache":
+                continue
+
+            if "libSDL_mixer" in f or "mixer_music" in f:
+                continue
+
+            rv.append(dirname + "/" + f)
+
+    return rv
 
 def main():
 
-    target = sys.argv[1]
-    gamedir = sys.argv[2]
+    if len(sys.argv) != 2:
+        print "Usage: %s <prefix>" % sys.argv[0]
+        return
 
-    # Read license.
-    lf = file("LICENSE.txt")
-    license = "#!/usr/bin/env python\n\n"
+    prefix = sys.argv[1]
+
+    compileall.compile_dir("renpy/", ddir=prefix + "/renpy/", force=1)
+
+    os.environ['RENPY_PATH_ELIDE'] = '/home/tom/ab/renpy:' + prefix
+
+    # Chmod the mac app.
+    os.chmod("./renpy.app/Contents/MacOS/Ren'Py Launcher", 0755)
+    
+    # Compile the various games
+    for i in [ 'tutorial/game', 'launcher', 'template/game', 'the_question/game' ]:
+        os.system("./renpy.sh --compile --game " + i)
     
-    for l in lf:
-        license += "# " + l
 
-    lf.close()
+    files = [ ]
+    more_files = [ ]
 
-    license = dosify(license)
+    files.append("CHANGELOG.txt")
+    files.append("LICENSE.txt")
+    files.extend(tree("common"))
+    more_files.append("console.exe")
+    files.extend(tree("launcher"))
+    files.extend(tree("tutorial"))
+    # files.extend(tree("dse"))
+    files.extend(tree("the_question"))
 
-    if os.path.exists(target):
-        raise Exception("Target exists!")
+#     editor = tree("editor")
+#     editor.remove("editor/scite.exe")
+#     files.append("editor/scite.exe")
+#     more_files.extend(editor)
 
-    # Start off with the target.
-    copy_tree("dist", target,
-              should_copy = lambda fn : fn not in [ 'traceback.txt' ] and not fn.endswith(".log"))
+    more_files.extend(tree("jedit"))
+    
+    # files.extend(tree("extras"))
+    more_files.extend(tree("lib"))
+    more_files.extend(tree("lib/linux-x86"))
 
-    # Copy renpy modules.
-    copy_tree("renpy", target + "/renpy",
-              should_copy = lambda fn : fn.endswith(".py"),              
-              license=license)
-
-    doc_files = [
-        'example.html',
-        'tutorial.html',
-        'style.css',
+    module_files = [
+        "lib/pysdlsound/linmixer.py",
+        "lib/pysdlsound/__init__.py",
+        "core.c",
+        "ffdecode.c",
+        "IMG_savepng.c",
+        "IMG_savepng.h",
+        "mmx.h",
+        "pss.c",
+        "pss.h",
+        "README.txt",
+        "_renpy.c",
+        "renpy_font.c",
+        "renpy.h",
+        "_renpy.pyx",
+        "renpy_ttf.c",
+        "renpy_ttf.h",
+        "rwobject.c",
+        "setup.py",
+        "sound.c",
+        "sound.pyx",
+        "subpixel.c",
+        "winmixer.c",
+        "winmixer.pyx",
+        "_renpybidi.c",
+        "renpybidicore.c",
+        "_renpybidi.pyx",
         ]
 
-    # Copy doc
-    copy_tree("doc", target + "/doc",
-              should_copy = lambda fn : fn in doc_files)
+    for i in module_files:
+        files.append('module/' + i)
 
-    # Copy the game
-    copy_tree(gamedir, target + "/game",
-              should_copy = lambda fn : not fn.startswith(".") and not fn.endswith("~"))
+    more_files.append('python25.dll')
+    more_files.append('msvcr71.dll')
+    files.extend(tree('renpy'))
+    more_files.extend(tree('renpy.app'))
+    more_files.append('renpy.code')
+    more_files.append('renpy.exe')
+    files.append('renpy.py')
 
-    copy_tree("common", target + "/common",
-              should_copy = lambda fn : not fn.startswith(".") and not fn.endswith("~"))
+    more_files.append('renpy.sh')
 
-    def cp(x, license=""):
-        copy_file(x, target + "/" + x)
+    files.extend(tree('template'))
+    # files.extend(tree('tools'))
 
-    cp("CHANGELOG.txt")
-    cp("LICENSE.txt")
-    cp("README_RENPY.txt")
-    cp("archive_images.bat")
-    cp("run_game.py", license=license)
-    cp("archiver.py", license=license)
-    cp("build_exe.py", license=license)
-    cp("add_from.py", license=license)
-    cp("renpy-mode.el")
+    files.append('doc/index.html')
+    files.append('doc/common.css')
+    files.append('doc/docs.css')
+    files.append('doc/monobook.css')
+    files.append('doc/monobook2.css')
+    files.append('doc/shared.css')
+    files.extend(tree('doc/reference'))
+    files.extend(tree('doc/tutorials'))
+    files.extend(tree('doc/images'))
     
-       
+    files.sort()
+    more_files.sort()
 
+    # zipup("dists/" + prefix + "-win32.zip", prefix, files)
+    # print "----"
+    zipup("dists/" + prefix + "-sdk.zip", prefix, files + more_files)
+    print "----"
+    tarup("dists/" + prefix + "-sdk.tar.bz2", prefix, files + more_files)
+    tarup("dists/" + prefix + "-source.tar.bz2", prefix, files)
 
+    # Make the 7zip.
+    os.chdir("dists")
+    os.system("unzip " + prefix + "-sdk.zip")
+
+    try:
+        os.unlink(prefix + "-sdk.7z")
+    except:
+        pass
+
+    os.system("7z a " + prefix + "-sdk.7z " + prefix)
+    os.system("cat ../7z.sfx " + prefix + "-sdk.7z > " + prefix + "-sdk.7z.exe""")
+    shutil.rmtree(prefix)
+    os.unlink(prefix + "-sdk.7z")
+    
+    print
+    print "Did you remember to rebuild the exe after the last change?"
+    print "Did you run me with renpython -OO?"
+    print "Was ming using the right crt?"
+    print "Did you update renpy.py and launcher/script_version.rpy?"
+    print "Did you run with a RENPY_SCALE_FACTOR?"
+    
 if __name__ == "__main__":
     main()
-
-    

doc/Makefile

@@ -1,12 +0,0 @@
-all:: tutorial.html example.html
-
-tutorial.html: tutorial.xml preprocess.py stylesheet.xslt style.css styles.xml
-	python preprocess.py tutorial.xml > tutorial.hi.xml
-	xsltproc stylesheet.xslt tutorial.hi.xml > tutorial.html
-	cp tutorial.html style.css ~/ab/website/renpy/devel/doc
-
-
-example.html: example.xml preprocess.py stylesheet.xslt style.css styles.xml ../demo2/script.rpy
-	python preprocess.py example.xml > example.hi.xml
-	xsltproc stylesheet.xslt example.hi.xml > example.html
-	cp example.html style.css ~/ab/website/renpy/devel/doc

doc/docs.css

@@ -0,0 +1,16 @@
+#bodyContent {
+    font-size: medium;
+    background: #fff;
+    margin-left: 20%;
+    margin-right: 20%;
+    padding: 1.5em;
+}
+
+.editsection {
+    display: none;
+}
+
+#bodyContent a.external {
+    background: none;
+    padding-right: 0px;
+}

doc/example.xml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-<doc> 
-  <title>Demo Script Example</title>
-
-  <p><a href="tutorial.html">Return to the tutorial.</a></p>
-
-  <example>
-<!-- include ../demo2/script.rpy -->
-  </example>
-
-  <p><a href="tutorial.html">Return to the tutorial.</a></p>
-
-</doc>

doc/get.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+wget http://www.renpy.org/w/skins/common/shared.css -O shared.css
+wget http://www.renpy.org/w/skins/monobook/main.css -O monobook.css
+wget 'http://www.renpy.org/w/index.php?title=MediaWiki:Common.css&usemsgcache=yes&action=raw&ctype=text/css&smaxage=18000' -O common.css
+wget 'http://www.renpy.org/w/index.php?title=MediaWiki:Monobook.css&usemsgcache=yes&action=raw&ctype=text/css&smaxage=18000' -O monobook2.css
+
+rm -Rf www.renpy.org
+wget -e robots=off -m -I /wiki/renpy/doc/reference/,/wiki/renpy/doc/tutorials/,/w/images -m http://www.renpy.org/wiki/renpy/doc/index
+
+rm -Rf images
+mkdir -p images
+cp `find www.renpy.org -name \*.png -type f` images
+
+No jpgs yet.
+cp `find www.renpy.org -name \*.jpg -type f` images
+
+rm -Rf reference tutorials
+python2.5 process.py

doc/preprocess.py

@@ -1,138 +0,0 @@
-#!/usr/bin/python
-
-import re
-import sys
-import time
-
-import inspect
-
-sys.path.append('..')
-import renpy
-
-
-keywords = [
-    r'\bimage\b',
-    r'\bscene\b',
-    r'\bshow\b',
-    r'\bhide\b',
-    r'\binit\b',
-    r'\$',
-    r'\blabel\b',
-    r'\bmenu\b',
-    r'\bset\b',
-    r'\bif\b',
-    r'\bwhile\b',
-    r'\bjump\b',
-    r'\blabel\b',
-    r'\bcall\b',
-    r'\breturn\b',
-    r'\bfrom\b',
-    r'\belif\b',
-    r'\belse\b',
-    r'\bpass\b',
-    r'\bwith\b',
-    r'\bat\b',
-    r'\bpython\b',
-    ]
-
-kwre = '|'.join(keywords)
-
-def example(m):
-    s = m.group(1)
-    rv = ""
-    pos = 0
-
-    while pos < len(s):
-
-        m = re.compile(r'(?s)"(([^"]|\\.)*)"').match(s, pos)
-        if m:
-            rv += '"<span class="string">%s</span>"' % m.group(1)
-            pos = m.end()
-            continue
-
-        m = re.compile(r"(?s)'(([^']|\\.)*)'").match(s, pos)
-        if m:
-            rv += '\'<span class="string">%s</span>\'' % m.group(1)
-            pos = m.end()
-            continue
-
-        m = re.compile(r"(?s)(#[^\n]+)").match(s, pos)
-        if m:
-            rv += '<span class="comment">%s</span>' % m.group(1)
-            pos = m.end()
-            continue
-
-
-        m = re.compile(kwre).match(s, pos)
-        if m:
-            rv += '<span class="keyword">%s</span>' % m.group(0)
-            pos = m.end()
-            continue
-
-
-        rv += s[pos]
-        pos += 1
-        
-
-    return "<example>" + rv + "</example>"
-
-def function(m):
-
-    name = m.group(1)
-
-    store = vars(renpy.store)
-    renpy.store.renpy = renpy.exports
-
-    func = eval(name, store)
-    
-    doc = func.__doc__
-
-    if inspect.isclass(func):
-        func = func.__init__
-        if func.__doc__:
-            doc += "\n" + func.__doc__
-
-        a, b, c, d = inspect.getargspec(func)
-        args = inspect.formatargspec(a[1:], b, c, d)
-    else:
-        args = inspect.formatargspec(*inspect.getargspec(func))
-        
-
-    docparas = []
-
-    for p in re.split(r'\n\s*\n', doc):
-        p = p.strip()
-        p = re.sub(r"\@param (\w+):", r'<param>\1</param> -', p)
-        p = "<p>" + p + "</p>"
-
-        docparas.append(p)
-
-    doc = '\n'.join(docparas)
-    
-    return '<function name="%(name)s" sig="%(args)s">%(doc)s</function>' % locals()
-
-def include(m):
-
-    f = file(m.group(1))
-    rv = f.read()
-    f.close()
-    return rv
-        
-    
-
-def main():
-
-    f = file(sys.argv[1])
-    s = f.read()
-    f.close()
-
-
-    s = re.sub(r"<!-- func (\S+) -->", function, s)
-    s = re.sub(r"<!-- include (\S+) -->", include, s)
-    s = re.sub(r"<!-- date -->", time.strftime("%04Y-%02m-%02d %02H:%02M"), s)
-    s = re.sub(r"(?s)<example>(.*?)</example>", example, s)
-
-    print s
-
-if __name__ == "__main__":
-    main()

doc/process.py

@@ -0,0 +1,164 @@
+#!/usr/bin/python2.4
+
+import sys
+import os.path
+
+# import xml.etree.ElementTree as elementtree
+# sys.modules['elementtree'] = elementtree
+
+# from elementtree.ElementTree import ElementTree, Element, SubElement, tostring, fromstring
+# from elementtidy import TidyHTMLTreeBuilder
+
+from xml.etree.ElementTree import ElementTree, Element, SubElement, tostring, fromstring
+from elementtidy import TidyHTMLTreeBuilder
+
+# Removes everyhing we don't care about from the wikipages.
+def remove_crap(n):
+
+    classes = n.attrib.get("class", "").split()
+    
+    if "editsection" in classes:
+        return None
+    if "printfooter" in classes:
+        return None    
+    if "magnify" in classes:
+        return None
+
+    
+    id = n.attrib.get("id", None)
+
+    if "catlinks" == id:
+        return None
+
+    newchildren = [ ]
+    for i in n:
+        i = remove_crap(i)
+        if i is not None:
+            newchildren.append(i)
+
+    n[:] = newchildren
+
+    if n.tag == "a" and not n.text:
+        n.text = "SPACE REMOVE ME PLEASE"
+        
+    return n
+    
+def process(src, dst, nav):
+
+    if nav:
+        nav = fromstring(nav)
+    
+    base = "../" * (len(dst.split('/')) - 1)
+
+    if dst.startswith("./"):
+        base = ""
+
+    # tree = TidyHTMLTreeBuilder.parse(src)
+
+    
+    code = file(src).read()
+    code = code.replace(" ", u"\u00a0".encode("utf-8"))
+    tree = fromstring(code)
+        
+    XHTML = "{http://www.w3.org/1999/xhtml}"
+
+    for elem in tree.getiterator():
+        if elem.tag.startswith(XHTML):
+            elem.tag = elem.tag[len(XHTML):]
+
+    by_id = dict()
+
+    for n in tree.getiterator():
+        if "id" in n.attrib:
+            by_id[n.attrib["id"]] = n
+
+    html = Element("html")
+    head = SubElement(html, "head")
+    title = SubElement(head, "title")
+    title.text = tree.findtext(".//title")
+    head = SubElement(head, "link", rel="stylesheet", href=base + "shared.css")
+    head = SubElement(head, "link", rel="stylesheet", href=base + "monobook.css")
+    head = SubElement(head, "link", rel="stylesheet", href=base + "common.css")
+    head = SubElement(head, "link", rel="stylesheet", href=base + "monobook2.css")
+    head = SubElement(head, "link", rel="stylesheet", href=base + "docs.css")
+    
+    body = SubElement(html, "body")
+    # gw = SubElement(body, "div", id="globalWrapper")
+    # cc = SubElement(gw, "div", id="column-content")
+    # content = SubElement(cc, "div", id="content")
+
+    bc = by_id['bodyContent']
+    body.append(bc)
+
+    bc.remove(by_id['siteSub'])
+    bc.remove(by_id['contentSub'])
+    bc.remove(by_id['jump-to-nav'])
+
+    for n in bc.findall(".//a"):
+        if "href" in n.attrib:
+            href = n.attrib['href']
+
+            if href.startswith("/wiki/Image:") or href.startswith("/w/"):
+                n.attrib['href'] = 'http://www.renpy.org' + href
+                continue
+
+            if href.startswith("#"):
+                continue
+            
+            if href.startswith("http:"):
+                continue
+            
+            href = href.replace("/wiki/renpy/doc/", base)
+
+            if "#" in href:
+                href.replace("#", ".html#")
+            else:
+                href += ".html"
+
+            n.attrib['href'] = href
+
+    for n in bc.findall(".//img"):
+        src = n.attrib["src"]
+        src = base + "images" + src[src.rfind("/"):]
+        n.attrib["src"] = src
+
+
+    if nav:
+        hr = Element("hr")
+        bc[:] = [ nav ] + list(bc) + [ hr, nav ]
+    
+    html = remove_crap(html)        
+
+    doc = tostring(html)
+    doc = doc.replace("SPACE REMOVE ME PLEASE", "")
+    file(dst, "w").write(doc)
+    
+    
+def process_dir(src, dst, nav):
+    try:
+        os.makedirs(dst)
+    except:
+        pass
+
+    for fn in os.listdir(src):
+        if os.path.isdir(src + "/" + fn):
+            continue
+
+        if fn.endswith(".1"):
+            continue
+
+        print src + "/" + fn
+        
+        process(src + "/" + fn, dst + "/" + fn + ".html", nav)
+
+nav = '<p class="docnav"><a href="../index.html">documentation index</a></p>'
+process_dir("www.renpy.org/wiki/renpy/doc/tutorials", "tutorials", nav) 
+
+nav = '<p class="docnav"><a href="../index.html">documentation index</a> &#x25e6; <a href="Reference_Manual.html">reference manual</a> &#x25e6; <a href="Function_Index.html">function index</a></p>'
+process_dir("www.renpy.org/wiki/renpy/doc/reference", "reference", nav) 
+
+nav = '<p class="docnav"><a href="../../index.html">documentation index</a> &#x25e6; <a href="../Reference_Manual.html">reference manual</a> &#x25e6; <a href="../Function_Index.html">function index</a></p>'
+process_dir("www.renpy.org/wiki/renpy/doc/reference/functions", "reference/functions", nav) 
+
+nav = ''
+process_dir("www.renpy.org/wiki/renpy/doc/", ".", nav) 

doc/style.css

@@ -1,81 +0,0 @@
-BODY {
-        font-family: sans-serif;
-}
-
-H1 {
-        text-align: center;
-        margin-top: 2em;
-        margin-bottom: 2em;
-}
-
-H2 {
-        text-align: center;
-        margin-top: 1em;
-        margin-bottom: 1em;
-}
-
-PRE.example {
-        border: 2px black solid;
-        margin-left: 10%;
-        margin-right: 10%;
-        background: #f0f0f0;
-        padding: 1em;
-        padding-bottom: 0em;
-}
-
-DIV.rule {
-       border: 2px black solid;
-       margin-left: 10%;
-       margin-right: 10%;
-       margin-bottom: 1em;
-
-       background: #f0f0ff;
-       padding: 1em;        
-}
-
-SPAN.comment {
-        color: #800000;
-}
-
-SPAN.string {
-        color: #006000;
-}
-
-SPAN.keyword {
-        color: #804000;
-}
-
-TD.funcname { 
-        font-family: monospace;
-        font-weight: bold;
-}
-
-TD.funcsig {
-        font-family: monospace;
-}
-
-DIV.funcbody {
-        margin-left: 5%;
-        margin-bottom: 1em;
-}
-
-SPAN.param {
-        font-style: italic;
-}
-
-P.prop {
-        margin-left: 5%;
-}
-
-SPAN.propname {
-        font-family: monospace;
-        font-weight: bold;
-}
-
-DT {
-        margin-top: 1em;
-}
-
-DT.code { 
-        font-family: monospace;
-}

doc/stylesheet.xslt

@@ -1,165 +0,0 @@
-<?xml version="1.0" encoding="ISO-8859-1"?>
-<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
-  
-  <!-- First, copy the element. -->
-  <xsl:template match="*" priority="-1">
-    <xsl:copy>
-      <xsl:copy-of select="@*" />
-      <xsl:apply-templates />
-    </xsl:copy>
-  </xsl:template>
-  
-  <!-- Now, handle some elements specially. -->
-  
-  <xsl:template match="doc">
-    <html>
-      <head>
-        <link rel="stylesheet" type="text/css" href="style.css" />
-        <title><xsl:value-of select="title" /></title>
-      </head>
-      <body>
-        <xsl:apply-templates />
-      </body>
-    </html>
-  </xsl:template>
-
-  <xsl:template match="toc">
-    <ol>
-      <xsl:for-each select="../h3">
-        <li>
-          <a>
-            <xsl:attribute name="href">#<xsl:value-of select="." /></xsl:attribute>
-            <xsl:value-of select="."/>
-          </a>
-        </li>
-      </xsl:for-each>
-    </ol>
-  </xsl:template>
-
-  <xsl:template match="funcindex">
-    <ul>
-      <xsl:for-each select="//function">
-        <xsl:sort select="@name" />
-        <li>
-          <a>
-            <xsl:attribute name="href">#<xsl:value-of select="@name" /></xsl:attribute>
-            <xsl:value-of select="@name"/>
-          </a>
-        </li>
-      </xsl:for-each>
-    </ul>
-  </xsl:template>
-
-  <xsl:template match="varindex">
-    <ul>
-      <xsl:for-each select="//var">
-        <xsl:sort select="@name" />
-        <li>
-          <a>
-            <xsl:attribute name="href">#<xsl:value-of select="@name" /></xsl:attribute>
-            <xsl:value-of select="@name"/>
-          </a>
-        </li>
-      </xsl:for-each>
-    </ul>
-  </xsl:template>
-
-  <xsl:template match="styleindex">
-    <ul>
-      <xsl:for-each select="//renpy_style">
-        <xsl:sort select="@name" />
-        <li>
-          <a>
-            <xsl:attribute name="href">#<xsl:value-of select="@name" /></xsl:attribute>
-            <xsl:value-of select="@name"/>
-          </a>
-        </li>
-      </xsl:for-each>
-    </ul>
-  </xsl:template>
-
-  <xsl:template match="propindex">
-    <ul>
-      <xsl:for-each select="//prop">
-        <xsl:sort select="@name" />
-        <li>
-          <a>
-            <xsl:attribute name="href">#<xsl:value-of select="@name" /></xsl:attribute>
-            <xsl:value-of select="@name"/>
-          </a>
-        </li>
-      </xsl:for-each>
-    </ul>
-  </xsl:template>
-
-  <xsl:template match="h3">
-    <a>
-      <xsl:attribute name="name"><xsl:value-of select="." /></xsl:attribute>
-      <h3><xsl:apply-templates /></h3>
-    </a>
-  </xsl:template>
-
-  <xsl:template match="title">
-    <h1><xsl:apply-templates /></h1>
-  </xsl:template>
-
-  <xsl:template match="subtitle">
-    <h2><xsl:apply-templates /></h2>
-  </xsl:template>
-
-  <xsl:template match="def">
-    <b><i><xsl:apply-templates /></i></b>
-  </xsl:template>
-
-  <xsl:template match="example">
-    <pre class="example"><xsl:apply-templates /></pre>
-  </xsl:template>
-
-  <xsl:template match="rule">
-    <div class="rule"><xsl:apply-templates /></div>
-  </xsl:template>
-
-  <xsl:template match="function">
-    <a><xsl:attribute name="name"><xsl:value-of select="@name" /></xsl:attribute></a>
-    <table>
-      <tr>
-        <td valign="top" class="funcname"><xsl:value-of select="@name" /></td>
-        <td class="funcsig"><xsl:value-of select="@sig" />:</td>
-      </tr>
-    </table>
-    <div class="funcbody">
-      <xsl:apply-templates />
-    </div>
-  </xsl:template>
-
-  <xsl:template match="param">
-    <span class="param"><xsl:apply-templates /></span>
-  </xsl:template>
-
-  <xsl:template match="prop">
-    <a><xsl:attribute name="name"><xsl:value-of select="@name" /></xsl:attribute></a>
-    <p class="prop">
-      <span class="propname"><xsl:value-of select="@name" /></span>
-      --- <xsl:apply-templates />
-    </p>
-  </xsl:template>
-
-  <xsl:template match="renpy_style">
-    <a><xsl:attribute name="name"><xsl:value-of select="@name" /></xsl:attribute></a>
-    <dt><b><xsl:value-of select="@name" /></b>:</dt>
-    <dd><xsl:apply-templates /></dd>
-  </xsl:template>
-
-  <xsl:template match="renpy_style_inherits">
-    (inherits from <b><xsl:apply-templates /></b>) <br />
-  </xsl:template>
-
-  <xsl:template match="var">
-    <a><xsl:attribute name="name"><xsl:value-of select="@name" /></xsl:attribute></a>
-    <dt class="var"><b><xsl:value-of select="@name" /></b> = <xsl:value-of select="@value" /></dt>
-    <dd>
-      <xsl:apply-templates />
-    </dd>
-  </xsl:template>
-    
-</xsl:stylesheet>

dse/game/day_planner.rpy

@@ -0,0 +1,137 @@
+# This contains code for the new day planner. You probably
+# don't want to change this file, but it might make sense to
+# change many of the variables or styles defined here from
+# other files.
+
+init -100 python:
+
+    # The frame containing the day planner.
+    style.dp_frame = Style(style.frame)
+    style.dp_vbox = Style(style.vbox)
+    style.dp_hbox = Style(style.hbox)
+
+    # The frame and vbox containing a single choice.
+    style.dp_choices = Style(style.default)
+    style.dp_choices_vbox = Style(style.vbox) 
+    style.dp_choices.xalign = 0.5
+    
+    # Buttons.
+    style.dp_choice_button = Style(style.button)
+    style.dp_choice_button_text = Style(style.button_text)
+
+    style.dp_done_button = Style(style.button)
+    style.dp_done_button_text = Style(style.button_text)
+
+    # Labels.
+    style.dp_label = Style(style.label)
+    style.dp_label_text = Style(style.label_text)
+
+    # The title of the done button.
+    dp_done_title = "Done Planning"
+
+    # A map from period name to the information we know about that
+    # period.
+    __periods = { }
+
+    # The period we're updating.
+    __period = None
+    
+    class __Period(object):
+
+        def __init__(self, name, var):
+            self.name = name
+            self.var = var
+            self.acts = [ ]
+
+    def dp_period(name, var):
+        __periods[name] = store.__period = __Period(name, var)
+
+    __None = object()
+        
+    def dp_choice(name, value=__None, enable="True", show="True"):
+
+        if not __period:
+            raise Exception("Choices must be part of a defined period.")
+
+        if value is __None:
+            value = name
+        
+        __period.acts.append((name, value, enable, show))
+
+    def __set_noncurried(var, value):
+        setattr(store, var, value)
+        return True
+        
+    __set = renpy.curry(__set_noncurried)
+        
+
+label day_planner(periods):
+
+    python hide:
+        renpy.choice_for_skipping()
+    
+label day_planner_repeat:
+
+    if renpy.has_label("dp_callback"):
+        call dp_callback
+    
+    python hide:
+    
+        ui.window(style=style.dp_frame)
+        ui.vbox(style=style.dp_vbox)
+        ui.hbox(style=style.dp_hbox)
+
+        can_continue = True
+
+        for p in periods:
+
+            if p not in __periods:
+                raise Exception("Period %r was never defined." % p)
+
+            ui.window(style=style.dp_choices)
+            ui.vbox(style=style.dp_choices_vbox)
+            
+            p = __periods[p]
+            v = getattr(store, p.var)
+
+            layout.label(p.name, "dp")
+
+            valid_choice = False
+            
+            for name, value, enable, show in p.acts:
+                show = eval(show)
+                enable = eval(enable)
+
+                selected = (v == value)
+                
+                if show:
+                    layout.button(
+                        name, 
+                        "dp_choice",
+                        clicked=__set(p.var, value),
+                        selected=selected,
+                        enabled=enable,
+                        )
+
+                if show and enable and selected:
+                    valid_choice = True
+
+            if not valid_choice:
+                can_continue = False
+
+            ui.close()
+                    
+        ui.close() # hbox.
+
+        layout.button(
+            dp_done_title,
+            "dp_done",
+            clicked=ui.returns(False),
+            enabled=can_continue)
+
+        ui.close() # vbox
+
+    if ui.interact():
+        jump day_planner_repeat
+    else:
+        return

dse/game/event_dispatcher.rpy

@@ -0,0 +1,328 @@
+# The Ren'Py/DSE event dispatcher. This file contains the code that
+# actually supports the running of events. Specifically, it contains
+# code that determines which events are available, which events can
+# run, and to actually run the events that should be run during a
+# given period.
+
+# This isn't really intended to be user-changable.
+
+init -100 python:
+
+    # A list of all of the events that the system knowns about,
+    # it's filtered to determine which events should run when.
+    all_events = [ ]
+
+    # The base class for events. When constructed, an event
+    # automatically adds itself to all_events.
+    #
+    # The first parameter for this is a unique name for the event,
+    # which is also used as the label that is called when the
+    # event executes.
+    #
+    # All other parameters are expressions. These expressions can
+    # be either strings, or objects having an eval method. Many
+    # interesting objects are given below.
+    #
+    # Keyword arguments are also kept on the object. Currently,
+    # there is one useful keyword argument, priority. This
+    # controls the order in which events are in the event list.
+    # (Events with lower priority number are evaluated first. If a
+    # priority is not specified, it's 100.)
+    class event(object):
+
+        def __repr__(self):
+            return '<event ' + self.name + '>'
+
+        def __init__(self, name, *args, **kwargs):
+
+            self.name = name
+
+            exprs = [ ]
+
+            for i in args:
+                if isinstance(i, basestring):
+                    exprs.append(event.evaluate(i))
+                else:
+                    exprs.append(i)
+
+            self.exprs = exprs
+
+            self.priority = kwargs.get('priority', 100)
+
+            all_events.append(self)
+
+        # Checks to see if this event is valid. It's called with
+        # a list of events that have already checked out to be
+        # True, and returns True if this event checks out.
+        def check(self, valid):
+
+            for i in self.exprs:
+                if not i.eval(self.name, valid):
+                    return False
+
+            return True
+
+        def properties(self):
+
+            rv = { }
+
+            for i in self.exprs:
+                rv.update(i.properties())
+
+            return rv
+
+
+        # The base class for all of the event checks given below.
+        class event_check(object):
+
+            def properties(self):
+                return { }
+
+            def __invert__(self):
+                return event.false(self)
+
+            def __and__(self, other):
+                return event.and_op(self, other)
+
+            def __or__(self, other):
+                return event.or_op(self, other)
+
+
+        # This evaluates the expression given as an argument, and the
+        # returns true if it evaluates to true.
+        class evaluate(event_check):
+
+            def __init__(self, expr):
+                self.expr = expr
+
+            def eval(self, name, valid):
+                return eval(self.expr)
+
+        # If present as a condition to an event, an object of this
+        # type ensures that the event will only execute once.
+        class once(event_check):
+            def eval(self, name, valid):
+                return name not in events_executed
+
+        # Returns True if no event of higher priority can execute,
+        # and false otherwise. In general, solo events should be
+        # the lowest priority, and are run if nothing else is.
+        class solo(event_check):
+            def eval(self, name, valid):
+
+                # True if valid is empty.
+                return not valid
+
+        # Returns True if no event of higher priority can execute.
+        # This also prevents other events from executing.
+        class only(solo):
+
+            def properties(self):
+                return dict(only=True)
+
+
+        # Returns True if the given events have happend already,
+        # at any time in the game. False if at least one hasn't
+        # happened yet.
+        class happened(event_check):
+            def __init__(self, *events):
+                self.events = events
+
+            def eval(self, name, valid):
+                for i in self.events:
+                    if i not in events_executed:
+                        return False
+
+                return True
+
+        # Returns True probability of the time, where probability
+        # is a number between 0 and 1.
+        class random(event_check):
+
+            def __init__(self, probability):
+                self.probability = probability
+
+            def eval(self, name, valid):
+                return renpy.random.random() <= self.probability
+
+        # Chooses only one from the group.
+        class choose_one(event_check):
+
+            def __init__(self, group, group_count=1):
+                self.group = group
+                self.group_count = group_count
+
+            def eval(self, name, valid):
+                return True
+
+            def properties(self):
+                return dict(group=self.group,
+                            group_count=self.group_count)
+
+
+        # Evaluates its argument, and returns true if it is false
+        # and vice-versa.
+        class false(event_check):
+            def __init__(self, cond):
+                self.cond = cond
+
+            def eval(self, name, valid):
+                return not self.cond.eval(name, valid)
+
+        # Handles the and operator.
+        class and_op(event_check):
+
+            def __init__(self, *args):
+                self.args = args
+
+            def eval(self, name, valid):
+                for i in self.args:
+                    if not i.eval(name, valid):
+                        return False
+                return True
+
+        # Handles the or operator.
+        class or_op(event_check):
+
+            def __init__(self, *args):
+                self.args = args
+
+            def eval(self, name, valid):
+                for i in self.args:
+                    if i.eval(name, valid):
+                        return True
+                return False
+
+        # Returns True if all of the events given as arguments have
+        # happened yesterday or earlier, or False otherwise.
+        class depends(event_check):
+            def __init__(self, *events):
+                self.events = events
+
+            def eval(self, name, valid):
+                for i in self.events:
+                    if i not in events_executed_yesterday:
+                        return False
+
+                return True
+
+
+    # The number of periods to skip.
+    skip_periods = 0
+
+    # This returns True if the current period should be skipped,
+    # or False if the current period should execute. If it returns
+    # True, it decrements skip_periods.
+    def check_skip_period():
+
+        global skip_periods
+
+        if skip_periods:
+            skip_periods -= 1
+            return True
+        else:
+            return False
+
+    def __events_init():
+        store.events_executed = { }
+        store.events_executed_yesterday = { }
+
+    config.start_callbacks.append(__events_init)
+        
+
+# This should called at the end of a (game) day, to let things
+# like depends_yesterday to work.
+label events_end_day:
+
+    $ skip_periods = 0
+
+    python hide:
+
+        # We can't skip between days.
+        skip_periods = 0
+
+        for k in events_executed:
+            events_executed_yesterday[k] = True
+
+    return
+    
+# This is called once per period, to determine, and then execute, the
+# events that should be run for that period. 
+label events_run_period:
+
+    $ events = [ ]
+
+    python hide:
+
+        eobjs = [ ]
+        egroups = { }
+        eingroup = { }
+
+        for i in all_events:
+            if not i.check(eobjs):
+                continue
+                
+            eobjs.append(i)
+
+            props = i.properties()
+
+            if 'group' in props:
+                group = props['group']
+                count = props['group_count']
+
+                egroups.setdefault(group, [ ]).extend([ i ] * count)
+                eingroup[i] = group
+
+            if 'only' in props:
+                break
+
+        echosen = { }
+
+        for k in egroups:
+            echosen[k] = renpy.random.choice(egroups[k])
+            
+        for i in eobjs:
+
+            if i in eingroup and echosen[eingroup[i]] is not i:
+                continue
+            
+            events.append(i.name)
+
+
+    while not check_skip_period() and events:
+
+        $ _event = events.pop(0)
+        $ events_executed[_event] = True
+
+        call expression _event from call_expression_event_1
+
+    return
+
+# If this is jumped to, it will end the current period immediately,
+# and return control to the main program.
+label events_end_period:
+
+    $ skip_period = 1
+    return
+
+# If this is jumped to, it will end the current period and skip
+# the next period. Use this if, say, the user goes on a date that
+# takes up two time slots.
+label events_skip_period:
+
+    $ skip_period = 2
+    return
+
+        
+init 100:
+    python hide:
+        # Sort all events on priority.
+        all_events.sort(key=lambda i : i.priority)
+
+    python hide:
+
+        for i in all_events:
+            if not renpy.has_label(i.name):
+                raise Exception("'%s' is defined as an event somewhere in the game, but no label named '%s' was defined anywhere." % (i.name, i.name))
+    
+

dse/game/events.rpy

@@ -0,0 +1,767 @@
+# This file contains the events that will be part of the game. It's
+# expected that the user will add and remove events as appropriate
+# for this game.
+
+
+# Some characters that are used in events in the game.
+init:
+    $ t = Character('Teacher')
+    $ gg = Character('Glasses Girl', color=(192, 255, 192, 255))
+    $ sg = Character('Sporty Girl', color=(255, 255, 192, 255))
+    $ bg = Character('Both Girls')
+    $ narrator = Character(' ')
+    
+# First up, we define some simple events for the various actions, that
+# are run only if no higher-priority event is about to occur.
+
+init:
+    $ event("class", "act == 'class'", event.only(), priority=200)
+    $ event("class_bad", "act == 'class'", priority=210)
+    $ event("cut1", "act == 'cut'", event.choose_one('cut'), priority=200)
+    $ event("cut2", "act == 'cut'", event.choose_one('cut'), priority=200)
+    $ event("study", "act == 'study'", event.solo(), priority=200)
+    $ event("hang", "act == 'hang'", event.solo(), priority=200)
+    $ event("exercise", "act == 'exercise'", event.solo(), priority=200)    
+    $ event("play", "act == 'play'", event.solo(), priority=200)
+
+label class:
+
+    "I make it to class just in time, and proceed to listen to the
+     teacher droning on about a wide range of topics, none of which
+     are remotely interesting."
+
+    return
+
+# For test purposes only.
+label class_bad:
+
+    "You shouldn't be seeing this."
+
+    "This is because class was declared with event.only(), which
+     should suspend processing of further events."
+
+    "This is really for testing purposes only."
+
+    return
+
+label cut1:
+
+    "I cut class, and spend the morning goofing off instead."
+    $ intelligence -= 10
+
+    return
+
+label cut2:
+
+    "I cut class, and spend the morning playing computer games."
+
+    return
+
+label study:
+
+    "I head on down to the library, and start reading about the topics
+     I should have been reading about in class."
+
+    $ intelligence += 10
+    return
+
+label hang:
+
+    "I spend the afternoon hanging out with my friends, killing
+     some time."
+    
+    return
+
+label exercise:
+
+    "I decide to go out for a run through the town, to keep myself in
+     shape."
+
+    $ strength += 10
+    return
+
+label play:
+
+    "I pop a DVD into my video game console, and spend the evening
+     rolling small cities up into balls."
+
+    $ strength -= 10
+    return
+
+
+# Below here are special events that are triggered when certain
+# conditions are true. 
+
+# This is an introduction event, that runs once when we first go
+# to class. 
+
+init:
+    $ event("introduction", "act == 'class'", event.once(), event.only())
+
+label introduction:
+
+    "I run to school, and make it to my seat just as the bell
+     signalling the start of class rings."
+
+    t "Before we start, I have an announcement to make."
+
+    t "We will have two new students joining us. Girls, come on in."
+
+    "Two girls walk in, and stand in front of the class."
+
+    "They're twins."
+
+    "Identical twins."
+
+    "Identical black hair, and the same pretty face."
+
+    "Despite that, it's still fairly easy to tell them apart."
+
+    "The one on the left is wearing glasses."
+
+    "Not too thick, but enough to let me know she probably reads alot
+     of books."
+
+    "If I look a little closely, I can find another difference."
+
+    "The one on the right probably exercises a bit more."
+
+    "I can tell by the muscle tone in her legs."
+
+    "I realize that I'm staring at her legs, and quickly look up."
+
+    "Suddenly, I realize that she's been talking for all this town."
+
+    sg "... to this town. And we hope to be friends with all of you."
+
+    sg "Well, that's about it. Sis, do you have anything to say?"
+
+    "The girl with glasses pauses for a second, and then quickly says:"
+
+    gg "{size=-4}It's good to meet you all.{/size}"
+
+    "She stops, and goes back to not saying anything."
+
+    t "Well, if that's all, you can take your seats and we can start
+       the class."
+
+    "They do, and our teacher begins his lecture."
+
+    "I don't think anyone pays much attention to it, however."
+
+    return
+
+
+# These are the events with glasses girl.
+
+init:
+    # The glasses girl is studying in the library, but we do not
+    # talk to her.
+    #
+    # 
+    $ event("gg_studying",
+
+            # This takes place when the action is 'study'.
+            "act == 'study'",
+
+            # This will only take place if no higher-priority
+            # event will occur.
+            event.solo(),
+
+            # This takes place at least one day after seeing the
+            # introduction event.
+            event.depends("introduction"),
+
+            # This takes priority over the study event.
+            priority=190)
+
+    # She asks to borrow our pen. 
+    $ event("borrow_pen",
+
+            # This takes place when we go to study, and we have an int
+            # >= 50. 
+            "act == 'study' and intelligence >= 50",
+
+            # It runs only once.
+            event.once(),
+
+            # It requires the introduction event to have run at least
+            # one day before.
+            event.depends("introduction"))
+
+    # After the pen, she smiles when she sees us.
+    $ event("gg_smiling", "act == 'study'",
+            event.solo(), event.depends("borrow_pen"),
+            priority = 180)
+
+    # The bookslide.
+    $ event("bookslide", "act == 'study' and intelligence == 100",
+            event.once(), event.depends("borrow_pen"))
+
+    # She makes us cookies.
+    $ event("cookies", "act == 'study'",
+            event.once(), event.depends("bookslide"))
+
+    # Her solo ending.
+    $ event("gg_confess", "act == 'class'",
+            event.once(), event.depends("cookies"))
+
+    
+label gg_studying:
+
+    "I head to the library, to get some studying done."
+
+    "The glasses girl is there, but she's busy reading a book, taking
+     notes as she does so."
+
+    "I decide not to disturb her, and instead start reading my own
+     book."
+
+    $ intelligence += 10
+
+    return
+
+label borrow_pen:
+
+    "I head to the library, to get some studying done."
+
+    "The glasses girl is there, but she's busy reading a book."
+
+    "I decide not to disturb her, and instead start reading my own
+     book."
+
+    "Suddenly, I feel a tap on my shoulder."
+
+    "I look up, and see the glasses girl standing right next to me."
+
+    gg "Excuse me, but can I borrow your pen?"
+
+    gg "Mine ran out of ink."
+
+    "I dig through my bag, to find the pen I had stashed there."
+
+    "While I'm looking, I point out that she seems to come to the
+     library alot."
+
+    gg "Hm... I guess you're right."
+
+    gg "There's so much stuff here, and I want to know about it all."
+
+    gg "Surely, you must feel the same way, as you're here almost as
+        much as I am."
+
+    "I don't have the heart to tell her that I'm only here to study so
+     that I don't fail out."
+
+    "My hand brushes the pen, and I quickly pull it out and give it to
+     her."
+
+    gg "Thank you."
+
+    "She says, and she goes back to studying."
+
+    return
+
+label gg_smiling:
+
+    "I head to the library, to get some studying done."
+
+    "The glasses girl is there, and smiles at me for a second before
+     turning back to her book."
+
+    "I decide not to disturb her, and instead start reading my own
+     book."
+
+    $ intelligence += 10
+
+    return
+
+label bookslide:
+
+    "I head to the library, to get some studying done."
+
+    "The glasses girl is standing right by the entrance, putting a
+     book back into a bookcase containing science books."
+
+    "It looks quite old, and quite weak, as if it could break at any
+     time."
+
+    "Suddenly, I hear a loud crack come from the bookcase."
+
+    "Without thinking, I throw myself between the girl and the
+     bookcase, pushing her out of the way in the process."
+
+    "As the shelves fail one by one, I'm hit with large textbooks on
+     topics ranging from Astronomy to Zoology."
+
+    "She's safe, but I'm knocked off my feet by the falling books."
+
+    "Before the dust even settled, the girl with glasses realized what
+     happened and asked:"
+
+    gg "Are you alright?"
+
+    "I tell her that I am, all the while rubbing a bruise left by a
+     particularly large Physics book."
+
+    gg "You saved me."
+
+    "She points out. I shrug... I guess I did, but it's not like I'm a
+     hero or anything."
+
+    "She extends out her hand, I take it, and she helps me to get up."
+
+    gg "Wow... Um..."
+
+    "She doesn't know what to say."
+
+    "I suggest that we help clean up the mess, mostly to take her off
+     the spot."
+
+    "She agrees, and together we begin piling the books up into neat
+     piles."
+
+    return
+
+
+label cookies:
+
+    "I head to the library, to get some studying done."
+
+    "The glasses girl is there, apparently waiting for me."
+
+    "She's holding a package in her hands."
+
+    gg "Here."
+
+    "She says, and she hands me the package."
+
+    "I take it from her, and open it."
+
+    "It contains fresh homemade cookies. Ginger snaps, I think."
+
+    gg "It's to thank you."
+
+    "She points out... She's probably not used to this. Especially
+     with guys."
+
+    "I take one of them, and stick it in my mouth."
+
+    "The taste is exquisite."
+
+    "It's perhaps one of the best cookies I've ever tasted."
+
+    "Of course it is. It's the only cookie I'd ever tasted that was
+     made for me by a beutiful girl."
+
+    "I tell her this... that it's delicious, not the girl part."
+
+    "But I do let slip that if I could eat these every day, I'd be the
+     happiest guy in the world."
+
+    "At this, she can only blush."
+
+    return
+
+label gg_confess:
+
+    "I once again barely make it to class on time."
+
+    "I sit down, at my desk, and put some of my books into it."
+
+    "My hand brushes a folded sheet of paper, one I didn't remember
+     putting in there."
+
+    "It's a girl's handwriting... \"Meet me on the roof at lunch.\""
+
+    "That's all it says... no signature or anything."
+
+    "Lunch is a few hours away, but the time passes like a blur."
+
+    "It's all I can do to avoid racing up to the roof... but I give it
+     some time anyway."
+
+    "It wouldn't make sense for me to get there first."
+
+    "I let two minutes elapse before leaving the classroom, and then
+     slowly walk the flights of stairs up to the roof."
+
+    "Standing there, I find the glasses girl."
+
+    "She's holding what looks like a homemade lunch... big enough for
+     two."
+
+    "I look at it, then her, then remember what I had said after she
+     made me the cookies."
+
+    "Finally, I ask her... \"Does this mean?\""
+
+    "She nods. It's all the confirmation I need."
+
+    "I sit down next to my new girlfriend... and together we start
+     eating her lunch."
+
+    "I'm probably the happiest guy in the world."
+
+    "But I still have to find out her name."
+
+    ".:. Ending 1."
+
+    $ renpy.full_restart()
+
+
+init:
+
+    $ event("catchme", "act == 'exercise'",
+            event.depends('introduction'), event.once())
+
+    $ event("cantcatchme", "act == 'exercise'",
+            event.depends('catchme'), event.solo(), priority=190)
+
+    $ event("caughtme", "act == 'exercise' and strength >= 50",
+            event.depends('catchme'), event.once())
+
+    $ event("together", "act == 'exercise' and strength >= 50",
+            event.depends('caughtme'), event.solo(), priority=180)
+
+    $ event("apart", "act == 'exercise' and strength < 50",
+            event.depends('caughtme'), event.solo(), priority=180)
+
+    $ event("pothole", "act == 'exercise' and strength >= 100",
+            event.depends('caughtme'), event.once())
+
+    $ event("dontsee", "act == 'exercise'",
+            event.depends('pothole'), event.solo(), priority=170)
+    
+    $ event("sg_confess", "act == 'class'",
+            event.depends('dontsee'), event.once())
+
+
+label catchme:
+
+    "I decide to go out for a run, to keep myself in shape."
+
+    "As I'm running through the town, I see a girl."
+
+    "She's one of the twins who transferred into my class."
+
+    "She waves, and comes over to me."
+
+    sg "I didn't know you were a runner."
+
+    "I point out that I'm not really a runner... I just run a little
+     bit at a time."
+
+    "I ask her if she wants to run with me for a while."
+
+    sg "As if! You couldn't keep up with me."
+
+    "I point out that I probably can."
+
+    sg "Well, let's see."
+
+    "We set off running, but she quickly pulls past me."
+
+    sg "See? Well, maybe we can try it again when you're a bit
+        faster."
+
+    sg "Until then, later."
+
+    "Even though I'm jogging, she pulls away as if it is nothing."
+
+    return
+
+label cantcatchme:
+
+    "I'm out running again, when the sporty girl catches up to me."
+
+    sg "Still at it?"
+
+    sg "Well, keep up the good work. One day you'll be as fast as me!"
+
+    sg "Well, maybe."
+
+    "She pulls out past me, and disappears into the distance. One day
+     I'll catch up to her."
+
+    $ strength += 10
+
+    return
+
+label caughtme:
+
+    "I'm out running again, when the sporty girl catches up to me."
+
+    sg "Still at it?"
+
+    sg "Well, keep up the good work. One day you'll be as fast as me!"
+
+    sg "Well, maybe."
+
+
+    "Today, however, I'm not about to let this stand unchallenged."
+
+    "I break out into a run, and for the first time ever, I keep up
+     with her."
+
+    "We both run, neck and neck, me keeping up with her."
+
+    "Finally, she starts slowing down, and we come to a stop
+     together."
+
+    sg "Not bad."
+
+    "She pauses to catch her breath."
+
+    sg "You've been practicing, and it really shows."
+    
+    sg "You've finally become fast enough to run with me."
+
+    "I nod, accepting her praise."
+
+    sg "We should do this more often... it's better to run with
+        someone else, to keep the challenge up."
+
+    "I nod again."
+
+    sg "Well, shall we go?"
+
+    "I nod a third time, and we take off, running side by side."
+
+    $ strength += 10
+
+    return
+
+label together:
+
+    "I start running, and meet up with the sporty girl as she passes
+     the street in front of my house."
+
+    "She's still better than me... she's been running for over a mile
+     before reaching this point."
+
+    "Still, I can keep up with her for the rest of the run. And that's
+     not bad."
+
+    $ strength += 10
+
+    return
+
+label apart:
+
+    "I start running, and meet up with the sporty girl as she passes
+     the street in front of my house."
+
+    "I try to keep up with her, but she pulls away from me."
+
+    "When she's a block away, she slows down and lets me catch up."
+
+    sg "It's your own fault... this is what you get for not
+        practicing."
+
+    "She's right, of course, and I redouble my efforts to try to keep
+     up with her."
+
+    $ strength += 10
+    return
+
+label pothole:
+
+    "I start running, and meet up with the sporty girl as she passes
+     the street in front of my house."
+
+    "We run together for several miles."
+
+    "I think about how much I've improved in our time together."
+
+    "And, although she probably won't admit it, I think she's improved
+     as well."
+
+    "I guess a little friendly competition is usually for the best."
+
+    "A small yelp pulls me out of my thought."
+
+    sg "Ow!"
+
+    "The sporty girl sits down, grabbing her ankle."
+
+    "I ask her what happened."
+
+    sg "I... hit a... pothole. Twisted my... ankle."
+
+    "I wince in sympathy."
+
+    "We wait a bit. I'm not sure what to do."
+
+    "Finally, I ask her if she can walk on it."
+
+    "She tries for a bit, but then winces in pain."
+
+    sg "No, I don't think so."
+
+    "I realize that we can't stay here."
+
+    "And so, I crouch down and motion for her to climb up onto my
+     back."
+
+    sg "What are you doing?"
+
+    "I explain that she can't stay out in the middle of the street
+     forever, and she won't get any help until I can get her home."
+
+    "And the only way to do that is for me to carry her."
+
+    "She accepts this, and climbs up onto my back."
+
+    "She wraps her arms around my neck, and I place my hands
+     underneath her to make a seat."
+
+    "I stand up, and start carrying her home."
+
+    return
+
+label dontsee:
+
+    "I go running again."
+
+    "But this time, I don't see the sporty girl."
+
+    "I finish the course that we usually take, but it's not the same
+     without her."
+
+    return
+
+label sg_confess:
+
+    "I once again barely make it to class on time."
+
+    "I sit down, at my desk, and put some of my books into it."
+
+    "My hand brushes a folded sheet of paper, one I didn't remember
+     putting in there."
+
+    "It's a girl's handwriting... \"Meet me on the roof at lunch.\""
+
+    "That's all it says... no signature or anything."
+
+    "Lunch is a few hours away, but the time passes like a blur."
+
+    "It's all I can do to avoid racing up to the roof... but I give it
+     some time anyway."
+
+    "It wouldn't make sense for me to get there first."
+
+    "I let two minutes elapse before leaving the classroom, and then
+     slowly walk the flights of stairs up to the roof."
+
+    "Standing there, I find the sporty girl."
+
+    "She's leaning on a crutch."
+
+    "I look at it for a second, and she notices that."
+
+    sg "I went to the doctor, and he gave me this."
+
+    sg "Looks like we won't be running together for a while."
+
+    "I nod."
+
+    sg "And that's why I asked you here."
+
+    sg "I couldn't stand the though of not seeing you for a few
+        weeks."
+
+    "I search my feelings, and realize I feel the same way."
+
+    sg "So I thought..."
+
+    "She doesn't say it... she doesn't need to."
+
+    "We both know how we feel about each other."
+
+    "And with that, we went from being running partners to partners in
+     a deeper sense."
+
+    "Now if I only knew her name..."
+
+    ".:. Ending 2."
+
+    $ renpy.full_restart()
+
+
+init:
+
+    # This needs to be higher-priority than either girl's ending.    
+    $ event('both_confess', 'act == "class"',
+            event.depends("dontsee"), event.depends("cookies"),
+            event.once(), priority = 50)
+     
+label both_confess:
+
+    "I once again barely make it to class on time."
+
+    "I sit down, at my desk, and put some of my books into it."
+
+    "My hand brushes a folded sheet of paper, then another."
+
+    "I take the first one out, and read it."
+
+    "It's a girl's handwriting... \"Meet me on the roof at lunch.\""
+
+    "That's all it says... no signature or anything."
+
+    "I take a look at the second one, and it says the same thing."
+
+    "Sure, the handwriting is a little different, but..."
+
+    "Lunch is a few hours away, but the time passes like a blur."
+
+    "It's all I can do to avoid racing up to the roof... but I give it
+     some time anyway."
+    
+    "I let two minutes elapse before leaving the classroom, and then
+     slowly walk the flights of stairs up to the roof."
+
+    "Standing there are the twins."
+
+    "Both of them."
+
+    "As in, the two notes came from the two twins."
+
+    "I ask them what they are doing there, feigning ignorance."
+
+    sg "Well, I invited you up here to confess to you..."
+
+    sg "... and then I found out that my sister here was about to do
+        the same thing."
+
+    gg "{size=-4}...I was...{/size}"
+
+    sg "When we found out, we were quite shocked, but after comparing
+        notes, we decide what we're going to do..."
+
+    "I quickly run through the possibilities in my head."
+
+    "The best cases involve them never talking to me again."
+
+    "The worst cases involve me being thrown off the roof."
+
+    bg "We're going to share you!"
+
+    "Eh?"
+
+    "That wasn't something I considered."
+
+    "Each of the girls grabs onto one of my arms."
+
+    "I don't know what the future holds for us..."
+
+    "... and I don't know if this will work out."
+
+    "But I do know that one day I will work up the courage to find out
+     their names."
+
+    ".:. Ending 3."
+
+    $ renpy.full_restart()
+    

dse/game/main.rpy

@@ -0,0 +1,163 @@
+# This is the main program. This can be changed quite a bit to
+# customize it for your program... But remember what you do, so you
+# can integrate with a new version of DSE when it comes out.
+
+# Set up a default theme.
+init python:
+    register_stat("Strength", "strength", 10, 100)
+    register_stat("Intelligence", "intelligence", 10, 100)
+
+    dp_period("Morning", "morning_act")
+    dp_choice("Attend Class", "class")
+    dp_choice("Cut Class", "cut")
+
+    dp_period("Afternoon", "afternoon_act")
+    dp_choice("Study", "study")
+    dp_choice("Hang Out", "hang")
+
+    dp_period("Evening", "evening_act")
+    dp_choice("Exercise", "exercise")
+    dp_choice("Play Games", "play")
+
+    
+# This is the entry point into the game.
+label start:
+
+    # Initialize the default values of some of the variables used in
+    # the game.
+    $ day = 0
+
+    # Show a default background.
+    scene black
+
+    # The script here is run before any event.
+
+    "In case you're just tuning in, here's the story of my life to
+     date."
+
+    "I'm a guy in the second year of high school."
+
+    "I'm not good at sports or school or even something as simple as
+     remembering peoples names."
+
+    "In short, I am your usual random loser guy."
+
+    "And this is my story..."
+
+
+    # We jump to day to start the first day.
+    jump day
+
+
+# This is the label that is jumped to at the start of a day.
+label day:
+
+    # Increment the day it is.
+    $ day += 1
+
+    # We may also want to compute the name for the day here, but
+    # right now we don't bother.
+
+    "It's day %(day)d."
+
+    # Here, we want to set up some of the default values for the
+    # day planner. In a more complicated game, we would probably
+    # want to add and remove choices from the dp_ variables
+    # (especially dp_period_acts) to reflect the choices the
+    # user has available to him.
+
+    $ morning_act = None
+    $ afternoon_act = None
+    $ evening_act = None
+
+    # Now, we call the day planner, which may set the act variables
+    # to new values. We call it with a list of periods that we want
+    # to compute the values for.
+    call day_planner(["Morning", "Afternoon", "Evening"])
+
+    
+    # We process each of the three periods of the day, in turn.
+label morning:
+
+    # Tell the user what period it is.
+    centered "Morning"
+
+    # Set these variables to appropriate values, so they can be
+    # picked up by the expression in the various events defined below. 
+    $ period = "morning"
+    $ act = morning_act
+
+    # Ensure that the stats are in the proper range.
+    $ normalize_stats()
+    
+    # Execute the events for the morning.
+    call events_run_period
+
+    # That's it for the morning, so we fall through to the
+    # afternoon.
+
+label afternoon:
+
+    # It's possible that we will be skipping the afternoon, if one
+    # of the events in the morning jumped to skip_next_period. If
+    # so, we should skip the afternoon.
+    if check_skip_period():
+        jump evening
+
+    # The rest of this is the same as for the morning.
+
+    centered "Afternoon"
+
+    $ period = "afternoon"
+    $ act = afternoon_act
+
+    $ normalize_stats()
+    
+    call events_run_period
+
+
+label evening:
+    
+    # The evening is the same as the afternoon.
+    if check_skip_period():
+        jump night
+
+    centered "Evening"
+
+    $ period = "evening"
+    $ act = evening_act
+
+    $ normalize_stats()
+    
+    call events_run_period
+
+
+label night:
+
+    # This is now the end of the day, and not a period in which
+    # events can be run. We put some boilerplate end-of-day text
+    # in here.
+
+    centered "Night"
+
+    "It's getting late, so I decide to go to sleep."
+
+    # We call events_end_day to let it know that the day is done.
+    call events_end_day
+
+    # And we jump back to day to start the next day. This goes
+    # on forever, until an event ends the game.
+    jump day
+         
+
+# This is a callback that is called by the day planner. One of the
+# uses of this is to show the statistics to the user.
+label dp_callback:
+
+    # Add in a line of dialogue asking the question that's on
+    # everybody's mind.
+    $ narrator("What should I do today?", interact=False)
+    $ display_stats()
+
+    return
+

dse/game/options.rpy

@@ -0,0 +1,249 @@
+## This file contains some of the options that can be changed to customize
+## your Ren'Py game. It only contains the most common options... there
+## is quite a bit more customization you can do.
+##
+## Lines beginning with two '#' marks are comments, and you shouldn't
+## uncomment them. Lines beginning with a single '#' mark are
+## commented-out code, and you may want to uncomment them when
+## appropriate.
+
+init -1 python hide:
+
+    ## Should we enable the use of developer tools? This should be
+    ## set to False before the game is released, so the user can't
+    ## cheat using developer tools.
+
+    config.developer = True
+
+    ## These control the width and height of the screen.
+
+    config.screen_width = 800
+    config.screen_height = 600
+
+    ## This controls the title of the window, when Ren'Py is
+    ## running in a window.
+
+    config.window_title = u"DSE Demo Game"
+
+    #########################################
+    # Layouts
+    
+    ## This enables the use of an in-game menu that is made out of
+    ## buttons.
+
+    layout.button_menu()
+
+    #########################################
+    # Themes
+    
+    ## We then want to call a theme function. themes.roundrect is
+    ## a theme that features the use of rounded rectangles. It's
+    ## the only theme we currently support.
+    ##
+    ## The theme function takes a number of parameters that can
+    ## customize the color scheme.
+
+    theme.roundrect(
+
+        ## The color of an idle widget face.
+        widget = "#003c78",
+
+        ## The color of a focused widget face.
+        widget_hover = "#0050a0",
+
+        ## The color of the text in a widget.
+        widget_text = "#c8ffff",
+
+        ## The color of the text in a selected widget. (For
+        ## example, the current value of a preference.)
+        widget_selected = "#ffd080",
+
+        ## The color of a disabled widget face. 
+        disabled = "#404040",
+
+        ## The color of disabled widget text.
+        disabled_text = "#c8c8c8",
+
+        ## The color of informational labels.
+        label = "#ffffff",
+
+        ## The color of a frame containing widgets.
+        frame = "#6496c8",
+
+        ## If this is True, the in-game window is rounded. If False,
+        ## the in-game window is square.
+        rounded_window = False,
+
+        ## The background of the main menu. This can be a color
+        ## beginning with '#', or an image filename. The latter
+        ## should take up the full height and width of the screen.
+        mm_root = "#dcebff",
+
+        ## The background of the game menu. This can be a color
+        ## beginning with '#', or an image filename. The latter
+        ## should take up the full height and width of the screen.
+        gm_root = "#dcebff",
+
+        ## And we're done with the theme. The theme will customize
+        ## various styles, so if we want to change them, we should
+        ## do so below.            
+        )
+
+    theme.outline_bars(
+        inside="#fff",
+        idle="#003c78",
+        hover="#0050a0")
+
+    #########################################
+    ## These settings let you customize the window containing the
+    ## dialogue and narration, by replacing it with an image.
+
+    ## The background of the window. In a Frame, the two numbers
+    ## are the size of the left/right and top/bottom borders,
+    ## respectively.
+
+    # style.window.background = Frame("frame.png", 12, 12)
+
+    ## Margin is space surrounding the window, where the background
+    ## is not drawn.
+
+    # style.window.left_margin = 6
+    # style.window.right_margin = 6
+    # style.window.top_margin = 6
+    # style.window.bottom_margin = 6
+
+    ## Padding is space inside the window, where the background is
+    ## drawn.
+
+    # style.window.left_padding = 6
+    # style.window.right_padding = 6
+    # style.window.top_padding = 6
+    # style.window.bottom_padding = 6
+
+    ## This is the minimum height of the window, including the margins
+    ## and padding.
+
+    # style.window.yminimum = 250
+
+
+    #########################################
+    ## This lets you change the placement of the main menu.
+
+    ## The way placement works is that we find an anchor point
+    ## inside a displayable, and a position (pos) point on the
+    ## screen. We then place the displayable so the two points are
+    ## at the same place.
+
+    ## An anchor/pos can be given as an integer or a floating point
+    ## number. If an integer, the number is interpreted as a number
+    ## of pixels from the upper-left corner. If a floating point,
+    ## the number is interpreted as a fraction of the size of the
+    ## displayable or screen.
+
+    # style.mm_menu_frame.xpos = 0.5
+    # style.mm_menu_frame.xanchor = 0.5
+    # style.mm_menu_frame.ypos = 0.75
+    # style.mm_menu_frame.yanchor = 0.5
+
+
+    #########################################
+    ## These let you customize the default font used for text in Ren'Py.
+
+    ## The file containing the default font.
+
+    # style.default.font = "DejaVuSans.ttf"
+
+    ## The default size of text.
+
+    # style.default.size = 22
+
+    ## Note that these only change the size of some of the text. Other
+    ## buttons have their own styles.
+
+
+    #########################################
+    ## These settings let you change some of the sounds that are used by
+    ## Ren'Py.
+
+    ## Set this to False if the game does not have any sound effects.
+
+    config.has_sound = True
+
+    ## Set this to False if the game does not have any music.
+
+    config.has_music = True
+
+    ## Set this to False if the game does not have voicing.
+
+    config.has_voice = True
+
+    ## Sounds that are used when button and imagemaps are clicked.
+
+    # style.button.activate_sound = "click.wav"
+    # style.imagemap.activate_sound = "click.wav"
+
+    ## Sounds that are used when entering and exiting the game menu.
+
+    # config.enter_sound = "click.wav"
+    # config.exit_sound = "click.wav"
+
+    ## A sample sound that can be played to check the sound volume.
+
+    # config.sample_sound = "click.wav"
+
+    ## Music that is played while the user is at the main menu.
+
+    # config.main_menu_music = "main_menu_theme.ogg"
+
+
+    #########################################
+    ## Transitions.
+
+    ## Used when entering the game menu from the game.
+
+    config.enter_transition = None
+
+    ## Used when exiting the game menu to the game.
+
+    config.exit_transition = None
+
+    ## Used between screens of the game menu.
+
+    config.intra_transition = None
+
+    ## Used when entering the game menu from the main menu.
+
+    config.main_game_transition = None
+
+    ## Used when returning to the main menu from the game.
+
+    config.game_main_transition = None
+
+    ## Used when entering the main menu from the splashscreen.
+
+    config.end_splash_transition = None
+
+    ## Used when entering the main menu after the game has ended.
+
+    config.end_game_transition = None
+
+    ## Used when a game is loaded.
+
+    config.after_load_transition = None
+
+    
+    #########################################
+    ## Default values of Preferences.
+
+    ## Note: These options are only evaluated the first time a
+    ## game is run. To have them run a second time, delete
+    ## game/saves/persistent
+
+    ## Should we start in fullscreen mode?
+
+    config.default_fullscreen = False
+
+    ## The default text speed in characters per second. 0 is infinite.
+
+    config.default_text_cps = 0
+

dse/game/stats.rpy

@@ -0,0 +1,88 @@
+init -100 python:
+
+    style.stats_frame = Style(style.frame)
+    style.stats_vbox = Style(style.vbox)
+
+    style.stats_label = Style(style.label)
+    style.stats_label_text = Style(style.label_text)
+
+    style.stat_side = Style(style.default)
+
+    style.stat_label = Style(style.label)
+    style.stat_label_text = Style(style.label_text)
+    style.stat_bar = Style(style.bar)
+    style.stat_value_label = Style(style.label)
+    style.stat_value_label_text = Style(style.label_text)
+        
+    __dse_stats = [ ]
+
+    class __Stat(object):
+
+        def __init__(self, name, var, default, max):
+            self.name = name
+            self.var = var
+            self.default = default
+            self.max = max
+
+    def __init_stats():
+        for s in __dse_stats:
+            setattr(store, s.var, s.default)
+
+    config.start_callbacks.append(__init_stats)
+            
+    def register_stat(name, var, default, max):
+        __dse_stats.append(__Stat(name, var, default, max))
+
+    def normalize_stats():
+        for s in __dse_stats:
+
+            v = getattr(store, s.var)
+
+            if v > s.max:
+                v = s.max
+            if v < 0:
+                v = 0
+
+            setattr(store, s.var, v)
+
+
+    def display_stats(name=True, bar=True, value=True, max=True):
+
+        normalize_stats()
+        
+        ui.window(style=style.stats_frame)
+        ui.vbox(style=style.stats_vbox)
+            
+        layout.label("Statistics", "stats")
+        
+        for s in __dse_stats:
+            v = getattr(store, s.var)
+
+            ui.side(['l', 'r', 'c'], style=style.stat_side)
+
+            if name:
+                layout.label(s.name, "stat")
+            else:
+                ui.null()
+
+            if value and max:
+                layout.label("%d/%d" % (v, s.max), "stat_value")
+            elif value:
+                layout.label("%d" % (v,), "stat_value")
+            elif max:
+                layout.label("%d" % (max,), "stat_value")
+            else:
+                ui.null()
+
+            if bar:
+                ui.bar(s.max, v, style=style.stat_bar)
+            else:
+                ui.null()
+
+            ui.close()
+                
+        ui.close()
+
+        
+    
+    

dse/game/styles.rpy

@@ -0,0 +1,49 @@
+# This file contains styles for the day planner.
+
+init python:
+
+    # Place the day planner.
+    style.dp_frame.ypos = 120
+    style.dp_frame.yanchor = 0.0
+    style.dp_frame.xalign = 0.5
+
+    # Spacing betweeen the choices and the done button.
+    style.dp_vbox.box_spacing = 20
+
+    # Spacing between the choice columns.
+    style.dp_hbox.box_spacing = 20
+
+    # Center the choices.
+    style.dp_choices.xalign = 0.5
+
+    # Center the label of each choice.
+    style.dp_label.xalign = 0.5
+    style.dp_label_text.text_align = 0.5
+
+    # Make each choice button the same size, and centered.
+    style.dp_choice_button.size_group = "dp_choice"
+    style.dp_choice_button.xalign = 0.5
+
+    # Center the done button.
+    style.dp_done_button.xalign = 0.5
+
+    # Put a margin on the stats frame.
+    style.stats_frame.xmargin = 10
+    style.stats_frame.ymargin = 5
+
+    # Space between the label and the stats.
+    style.stats_vbox.box_first_spacing = 10
+
+    # Put blank space around each stat name, and right-justify.
+    style.stat_label.xminimum = 140
+    style.stat_label_text.xalign = 1.0
+    style.stat_label.xmargin = 5
+    
+    # Put blank space around each stat value, and right-justify.
+    style.stat_value_label.xminimum = 100
+    style.stat_value_label_text.xalign = 1.0
+    
+    
+    # Center the stat bar vertically.
+    style.stat_bar.yalign = 0.5
+

dse/launcherinfo.py

@@ -0,0 +1,2 @@
+description = "A game that demonstrates the use of the dating-sim engine. A non-graphical proof of concept."
+ro = True

help.html

@@ -0,0 +1,128 @@
+<html>
+<head>
+<title>README</title>
+<style>
+
+BODY {
+background: #fff;
+color: #444;
+padding-left: 20%;
+padding-top: 1em;
+padding-bottom: 1em;
+padding-right: 20%;
+font-family: sans-serif;
+line-height: 1.6em;
+}
+
+DT {
+font-weight: bold;
+margin-top: .33em;
+}
+
+H2 {
+color: #000;
+margin-left: -2.5em;
+}
+
+H3 {
+color: #000;
+margin-left: -1.5em;
+}
+
+.editsection {
+display: none;
+}
+
+</style>
+</head>
+<body>
+
+<div id="renpy_help"></div>
+
+
+
+
+<p><a name="Basic_Help" id="Basic_Help"></a></p> 
+<h2><span class="editsection">[<a href="/w/index.php?title=renpy/Help&amp;action=edit&amp;section=1" title="Edit section: Basic Help">edit</a>]</span> <span class="mw-headline">Basic Help</span></h2> 
+<p>To advance through the game, <tt>left-click</tt> or press the <tt>space</tt> or <tt>enter</tt> keys. When at a menu, <tt>left-click</tt> to make a choice, or use the arrow keys to select a choice and <tt>enter</tt> to activate it.</p> 
+<p><a name="Game_Menu" id="Game_Menu"></a></p> 
+<h3><span class="editsection">[<a href="/w/index.php?title=renpy/Help&amp;action=edit&amp;section=2" title="Edit section: Game Menu">edit</a>]</span> <span class="mw-headline">Game Menu</span></h3> 
+<p>When playing a game, <tt>right-click</tt> or press the <tt>escape</tt> key to enter the game menu. The game menu gives the following choices:</p> 
+<dl> 
+<dt>Return</dt> 
+<dd>Returns to the game.</dd> 
+<dt>Save Game</dt> 
+<dd>Allows you to save a game by clicking on a save slot.</dd> 
+<dt>Load Game</dt> 
+<dd>Allows you to load a game by clicking on a save slot. Clicking on "Auto" accesses the automatic save slots.</dd> 
+<dt>Preferences</dt> 
+<dd>Changes the game preferences (options/configuration):
+<dl> 
+<dt>Display</dt> 
+<dd>Switches between fullscreen and windowed mode.</dd> 
+<dt>Transitions</dt> 
+<dd>Controls the display of transitions between game screens.</dd> 
+<dt>Text Speed</dt> 
+<dd>Controls the rate at which text displays. The further to the right this slider is, the faster the text will display. All the way to the right causes text to be shown instantly.</dd> 
+<dt>Joystick</dt> 
+<dd>Lets you control the game using a joystick.</dd> 
+<dt>Skip</dt> 
+<dd>Chooses between skipping messages that have been already seen (in any play through the game), and skipping all messages.</dd> 
+<dt>Begin Skipping</dt> 
+<dd>Returns to the game, while skipping.</dd> 
+<dt>After Choices</dt> 
+<dd>Controls if skipping stops upon reaching a menu.</dd> 
+<dt>Auto-Forward Time</dt> 
+<dd>Controls automatic advance. The further to the left this slider is, the shorter the amount of time before the game advances. All the way to the right means text will never auto-forward.</dd> 
+<dt>Music, Sound, and Voice Volume</dt> 
+<dd>Controls the volume of the Music, Sound effect, and Voice channels, respectively. The further to the right these are, the louder the volume.</dd> 
+</dl> 
+</dd> 
+</dl> 
+<dl> 
+<dt>Main Menu</dt> 
+<dd>Returns to the main menu, ending the current game.</dd> 
+<dt>Help</dt> 
+<dd>Shows this help screen.</dd> 
+<dt>Quit</dt> 
+<dd>Exits the game; the game will be closed and ended.</dd> 
+</dl> 
+<p><a name="Key_and_Mouse_Bindings" id="Key_and_Mouse_Bindings"></a></p> 
+<h3><span class="editsection">[<a href="/w/index.php?title=renpy/Help&amp;action=edit&amp;section=3" title="Edit section: Key and Mouse Bindings">edit</a>]</span> <span class="mw-headline">Key and Mouse Bindings</span></h3> 
+<dl> 
+<dt>Left-click, Enter</dt> 
+<dd>Advances through the game, activates menu choices, buttons, and sliders.</dd> 
+<dt>Space</dt> 
+<dd>Advances through the game, but does not activate choices.</dd> 
+<dt>Arrow Keys</dt> 
+<dd>Selects menu choices, buttons, and sliders.</dd> 
+<dt>Ctrl</dt> 
+<dd>Causes skipping to occur while the ctrl key is held down.</dd> 
+<dt>Tab</dt> 
+<dd>Toggles skipping, causing it to occur until tab is pressed again.</dd> 
+<dt>Mousewheel-Up, PageUp</dt> 
+<dd>Causes rollback to occur. Rollback reverses the game back in time, showing prior text and even allowing menu choices to be changed.</dd> 
+<dt>Mousewheel-Down, PageDown</dt> 
+<dd>Causes rollforward to occur, cancelling out a previous rollback.</dd> 
+<dt>Right-click, Escape</dt> 
+<dd>Enters the game menu. When in the game menu, returns to the game.</dd> 
+<dt>Middle-click, H</dt> 
+<dd>Hides the text window and other transient displays.</dd> 
+<dt>F</dt> 
+<dd>Toggles fullscreen mode</dd> 
+<dt>S</dt> 
+<dd>Takes a screenshot, saving it in a file named screenshotxxxx.png, where xxxx is a serial number.</dd> 
+<dt>Alt-H, Command-H</dt> 
+<dd>Hides (iconifies) the window.</dd> 
+<dt>Alt-F4, Command-Q</dt> 
+<dd>Quits the game.</dd> 
+<dt>Delete</dt> 
+<dd>When a save slot is selected, deletes that save slot.</dd> 
+</dl> 
+<p><a name="Legal_Notice" id="Legal_Notice"></a></p> 
+<h2><span class="editsection">[<a href="/w/index.php?title=renpy/Help&amp;action=edit&amp;section=4" title="Edit section: Legal Notice">edit</a>]</span> <span class="mw-headline">Legal Notice</span></h2> 
+<p>This game uses source code from a number of open source projects. For a list, and a location where the source code can be downloaded from, please view the LICENSE.txt file in the renpy directory, or visit <a href="http://www.renpy.org/wiki/renpy/License" class="external free" title="http://www.renpy.org/wiki/renpy/License" rel="nofollow">http://www.renpy.org/wiki/renpy/License</a> .</p> 
+
+
+</body>
+</html>

launcher/EasyDialogsResources.py

@@ -0,0 +1,144 @@
+import binascii
+
+
+def a2b(a):
+    return binascii.a2b_hex(''.join(a.split()))
+
+
+resources = {
+             260 : a2b('''
+                          01 00 ff ff 00 00 00 00  00 00 00 00 c8 00 c0 80
+                          02 00 00 00 00 00 b8 00  29 00 00 00 00 00 00 00
+                          08 00 90 01 00 01 4d 00  53 00 20 00 53 00 68 00
+                          65 00 6c 00 6c 00 20 00  44 00 6c 00 67 00 00 00
+                          00 00 00 00 00 00 00 00  01 00 01 50 7f 00 14 00
+                          32 00 0e 00 01 00 00 00  ff ff 80 00 4f 00 4b 00
+                          00 00 00 00 00 00 00 00  00 00 00 00 04 08 00 50
+                          07 00 07 00 aa 00 0c 00  ea 03 00 00 ff ff 81 00
+                          00 00 00 00             
+                       '''),
+             261 : a2b('''
+                          01 00 ff ff 00 00 00 00  00 00 00 00 c8 00 c0 80
+                          04 00 00 00 00 00 b8 00  3a 00 00 00 00 00 00 00
+                          08 00 90 01 00 01 4d 00  53 00 20 00 53 00 68 00
+                          65 00 6c 00 6c 00 20 00  44 00 6c 00 67 00 00 00
+                          00 00 00 00 00 00 00 00  80 00 81 50 07 00 14 00
+                          aa 00 0c 00 ec 03 00 00  ff ff 81 00 00 00 00 00
+                          00 00 00 00 00 00 00 00  01 00 01 50 7f 00 25 00
+                          32 00 0e 00 01 00 00 00  ff ff 80 00 4f 00 4b 00
+                          00 00 00 00 00 00 00 00  00 00 00 00 00 00 01 50
+                          4a 00 25 00 32 00 0e 00  02 00 00 00 ff ff 80 00
+                          43 00 61 00 6e 00 63 00  65 00 6c 00 00 00 00 00
+                          00 00 00 00 00 00 00 00  04 08 00 50 07 00 07 00
+                          aa 00 0c 00 eb 03 00 00  ff ff 81 00 00 00 00 00
+                       '''),
+             262 : a2b('''
+                          01 00 ff ff 00 00 00 00  00 00 00 00 c8 00 c0 80
+                          04 00 00 00 00 00 b8 00  29 00 00 00 00 00 00 00
+                          08 00 90 01 00 01 4d 00  53 00 20 00 53 00 68 00
+                          65 00 6c 00 6c 00 20 00  44 00 6c 00 67 00 00 00
+                          00 00 00 00 00 00 00 00  00 00 01 50 7f 00 14 00
+                          32 00 0e 00 06 00 00 00  ff ff 80 00 59 00 65 00
+                          73 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00
+                          04 08 00 50 07 00 07 00  aa 00 0c 00 ed 03 00 00
+                          ff ff 81 00 00 00 00 00  00 00 00 00 00 00 00 00
+                          00 00 01 50 07 00 14 00  32 00 0e 00 07 00 00 00
+                          ff ff 80 00 4e 00 6f 00  00 00 00 00 00 00 00 00
+                          00 00 00 00 00 00 01 50  4b 00 14 00 32 00 0e 00
+                          02 00 00 00 ff ff 80 00  43 00 61 00 6e 00 63 00
+                          65 00 6c 00 00 00 00 00         
+                       '''),
+             263 : a2b('''
+                          01 00 ff ff 00 00 00 00  00 00 00 00 80 00 ca 80
+                          03 00 00 00 00 00 e2 00  29 00 00 00 00 00 00 00
+                          00 00 00 00 00 00 00 00  00 00 81 50 07 00 14 00
+                          97 00 0e 00 eb 03 00 00  6d 00 73 00 63 00 74 00
+                          6c 00 73 00 5f 00 70 00  72 00 6f 00 67 00 72 00
+                          65 00 73 00 73 00 33 00  32 00 00 00 00 00 00 00
+                          00 00 00 00 00 00 00 00  04 08 00 50 07 00 07 00
+                          d4 00 0c 00 ea 03 00 00  ff ff 81 00 00 00 00 00
+                          00 00 00 00 00 00 00 00  00 00 00 50 a9 00 14 00
+                          32 00 0e 00 02 00 00 00  ff ff 80 00 43 00 61 00
+                          6e 00 63 00 65 00 6c 00  00 00 00 00    
+                       '''),
+             264 : a2b('''
+                          01 00 ff ff 00 00 00 00  00 00 00 00 c8 00 c0 80
+                          04 00 00 00 00 00 b8 00  3a 00 00 00 00 00 00 00
+                          08 00 90 01 00 01 4d 00  53 00 20 00 53 00 68 00
+                          65 00 6c 00 6c 00 20 00  44 00 6c 00 67 00 00 00
+                          00 00 00 00 00 00 00 00  a0 00 81 50 07 00 14 00
+                          aa 00 0c 00 ec 03 00 00  ff ff 81 00 00 00 00 00
+                          00 00 00 00 00 00 00 00  01 00 01 50 7f 00 25 00
+                          32 00 0e 00 01 00 00 00  ff ff 80 00 4f 00 4b 00
+                          00 00 00 00 00 00 00 00  00 00 00 00 00 00 01 50
+                          4a 00 25 00 32 00 0e 00  02 00 00 00 ff ff 80 00
+                          43 00 61 00 6e 00 63 00  65 00 6c 00 00 00 00 00
+                          00 00 00 00 00 00 00 00  04 08 00 50 07 00 07 00
+                          aa 00 0c 00 eb 03 00 00  ff ff 81 00 00 00 00 00
+                       '''),
+             265 : a2b('''
+                          01 00 ff ff 00 00 00 00  00 00 00 00 c8 00 c8 80
+                          12 00 00 00 00 00 d9 00  fc 00 00 00 00 00 00 00
+                          08 00 90 01 00 01 4d 00  53 00 20 00 53 00 68 00
+                          65 00 6c 00 6c 00 20 00  44 00 6c 00 67 00 00 00
+                          00 00 00 00 00 00 00 00  01 00 01 50 6c 00 ea 00
+                          30 00 0e 00 01 00 00 00  ff ff 80 00 4f 00 4b 00
+                          00 00 00 00 00 00 00 00  00 00 00 00 00 00 01 50
+                          a2 00 ea 00 30 00 0e 00  02 00 00 00 ff ff 80 00
+                          43 00 61 00 6e 00 63 00  65 00 6c 00 00 00 00 00
+                          00 00 00 00 00 00 00 00  07 00 00 50 06 00 06 00
+                          cc 00 4e 00 ff ff ff ff  ff ff 80 00 00 00 00 00
+                          00 00 00 00 00 00 00 00  03 00 21 50 48 00 12 00
+                          84 00 64 00 03 00 00 00  ff ff 85 00 00 00 00 00
+                          00 00 00 00 00 00 00 00  00 00 02 50 0c 00 24 00
+                          c0 00 08 00 04 00 00 00  ff ff 82 00 00 00 00 00
+                          00 00 00 00 00 00 00 00  80 00 81 50 0c 00 30 00
+                          c0 00 0e 00 05 00 00 00  ff ff 81 00 00 00 00 00
+                          00 00 00 00 00 00 00 00  00 00 01 50 9c 00 42 00
+                          30 00 0e 00 06 00 00 00  ff ff 80 00 41 00 64 00
+                          64 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00
+                          07 00 00 50 06 00 54 00  cb 00 3c 00 ff ff ff ff
+                          ff ff 80 00 00 00 00 00  00 00 00 00 00 00 00 00
+                          03 00 21 50 48 00 61 00  84 00 64 00 07 00 00 00
+                          ff ff 85 00 00 00 00 00  00 00 00 00 00 00 00 00
+                          00 00 02 50 0c 00 72 00  c0 00 08 00 08 00 00 00
+                          ff ff 82 00 00 00 00 00  00 00 00 00 00 00 00 00
+                          00 00 01 50 9c 00 7e 00  30 00 0e 00 09 00 00 00
+                          ff ff 80 00 41 00 64 00  64 00 00 00 00 00 00 00
+                          00 00 00 00 00 00 00 00  00 00 01 50 06 00 96 00
+                          42 00 0e 00 0a 00 00 00  ff ff 80 00 41 00 64 00
+                          64 00 20 00 66 00 69 00  6c 00 65 00 2e 00 2e 00
+                          2e 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00
+                          00 00 01 50 4e 00 96 00  42 00 0e 00 0b 00 00 00
+                          ff ff 80 00 41 00 64 00  64 00 20 00 6e 00 65 00
+                          77 00 20 00 66 00 69 00  6c 00 65 00 2e 00 2e 00
+                          2e 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00
+                          00 00 01 50 06 00 a8 00  42 00 0e 00 0c 00 00 00
+                          ff ff 80 00 41 00 64 00  64 00 20 00 66 00 6f 00
+                          6c 00 64 00 65 00 72 00  2e 00 2e 00 2e 00 00 00
+                          00 00 00 00 00 00 00 00  00 00 00 00 07 00 00 50
+                          06 00 c6 00 cc 00 1e 00  ff ff ff ff ff ff 80 00
+                          43 00 6f 00 6d 00 6d 00  61 00 6e 00 64 00 20 00
+                          6c 00 69 00 6e 00 65 00  3a 00 00 00 00 00 00 00
+                          00 00 00 00 00 00 00 00  80 00 81 50 0c 00 d2 00
+                          c0 00 0e 00 0e 00 00 00  ff ff 81 00 00 00 00 00
+                          00 00 00 00 00 00 00 00  00 00 02 50 0c 00 14 00
+                          3c 00 08 00 1e 00 00 00  ff ff 82 00 4f 00 70 00
+                          74 00 69 00 6f 00 6e 00  3a 00 00 00 00 00 00 00
+                          00 00 00 00 00 00 00 00  00 00 02 50 0c 00 63 00
+                          3c 00 08 00 46 00 00 00  ff ff 82 00 43 00 6f 00
+                          6d 00 6d 00 61 00 6e 00  64 00 3a 00 00 00 00 00
+                       '''),
+             270 : a2b('''
+                          01 00 ff ff 00 00 00 00  00 00 00 00 48 04 00 44
+                          02 00 00 00 00 00 23 01  1a 00 00 00 00 00 00 00
+                          08 00 00 00 00 00 4d 00  53 00 20 00 53 00 68 00
+                          65 00 6c 00 6c 00 20 00  44 00 6c 00 67 00 00 00
+                          00 00 00 00 00 00 00 00  01 00 02 50 00 00 07 00
+                          23 01 08 00 ff ff ff ff  ff ff 82 00 53 00 74 00
+                          61 00 74 00 69 00 63 00  00 00 00 00 00 00 00 00
+                          00 00 00 00 00 00 02 40  00 00 12 00 23 01 08 00
+                          5f 04 00 00 ff ff 82 00  73 00 74 00 63 00 33 00
+                          32 00 00 00 00 00           
+                       '''),
+            }

launcher/None.editor.py

@@ -0,0 +1,6 @@
+# Name: None
+# Version: 1
+# Description: Disables the automatic launching of an editor.
+
+config.editor = None
+config.editor_transient = None