Bump version to 6.17.0.

This might lead to a slight speedup in sphinx, which seems to cache
unchanged files.

.gitignore

@@ -0,0 +1,54 @@
+*.rpyc
+*.rpyb
+*.rpymc
+*.pyc
+*.pyo
+
+*~
+*.bak 
+
+saves
+tmp
+cache
+
+log.txt
+errors.txt
+traceback.txt
+
+styles.txt
+
+/android
+/build
+/dist
+/dists
+/renpy.app
+/jedit
+/lint.txt
+/renpy.code
+/*testing*
+/screenshot*
+/renpy.exe
+/lib
+/lib.old
+/doc
+/.pydevproject
+/.pydevproject.bak
+/.project
+/.settings
+/LICENSE.txt
+/templates/english/README.html
+/the_question/README.html
+/tutorial/README.html
+/renpy/angle/*.pyx
+/renpy/angle/*.pxd
+/renpy-ppc.zip
+/module/build
+/module/gen
+/editra
+/launcher/game/theme
+/launcher/game/script_version.rpy
+
+dl
+renpy/vc_version.py
+.externalToolBuilders
+rapt-*

LICENSE.txt

@@ -1,793 +0,0 @@
-Copyright 2004-2007 PyTom <pytom@bishoujo.us>
-
-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.
-
----
-
-(The above is the MIT License)
-
-Please see each individual source file for a list of copyright
-holders. The pictures of Eileen in the demo are Copyright 2006
-Piroshki, 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_sound (LGPL)
-    * SDL_ttf (LGPL)
-    * SDL_mixer (LGPL)
-    * Freetype (LGPL)
-    * jpeg (JPEG License)
-    * libmodplug (Public Domain)
-    * libogg (Xiph.org License)
-    * libpng (PNG license)
-    * libvorbis (Xiph.org License)
-    * smpeg (LGPL)
-    * speex (Xiph.org License)
-    * zlib (Zlib License) 
-    * bzip2 (Bzip2 License)
-    * pyobjc (MIT License)
-
-The Linux launcher 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.
-
-
-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.
-
-
-Xiph.org License
-----------------
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-- Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-
-- Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.
-
-- Neither the name of the Xiph.org Foundation nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-``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 FOUNDATION
-OR CONTRIBUTORS 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.
-
-
-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.

README.rst

@@ -0,0 +1,55 @@
+==============================
+The Ren'Py Visual Novel Engine
+==============================
+
+http://www.renpy.org
+
+
+Branches
+========
+
+Ren'Py development takes place on two branches, ``master`` and
+``devel``, as well as the occasional feature branch.
+
+Master
+-----
+
+The master branch contains code that can be run using the libraries in
+the latest (release or pre-release) version of Ren'Py. It's used for
+bugfixes and features that do not require C or Cython code to
+implement.
+
+After checking out master, run::
+
+    ./after_checkout.sh <path-to-renpy>
+
+to link in the libraries from the most recent Ren'Py. (On Windows, you
+will need to run this under msys or cygwin.)
+
+Ren'Py can then be run by running renpy.exe, renpy.sh, or renpy.app as
+appropriate.
+
+Devel
+-----
+
+The devel branch contains code that requires a recompile of modules
+implemented in C or Cython. Building devel requires you to have the
+prerequisite libraries installed. Then set RENPY_DEPS_INSTALLED to
+a \::-separated list of paths containing dependencies. For example::
+
+  export RENPY_DEPS_INSTALL=/usr::/usr/lib/x86_64-linux-gnu/
+
+Finally, change into the modules directory, and run::
+
+  python setup.py install
+
+Ren'Py can then be run by using python to run renpy.py.
+
+
+Contributing
+============
+
+For bug fixes, documentation improvements, and simple changes, just
+make a pull request. For more complex changes, it might make sense
+to file an issue so we can discuss the design.
+

README_RENPY.txt

@@ -1,55 +0,0 @@
-This file contains boilerplate information about running Ren'Py that
-can be included into the README for your game. It may be necessary to
-change some of the filenames in this document, to make it specific to
-your game.
-
-Feel free to use this in your projects.
-
-
-
-Running the Game
-================
-
-(Windows)
-
-If this game was installed on Windows using an installer, then you can
-run it by choosing the shortcut left by the installer. If this game
-was installed on Windows using the cross-platform zip file, then it
-can be run by executing the run_game.exe file.
-
-(Macintosh)
-
-For information about running Ren'Py games on Mac OS 10.3 or higher,
-please go to http://www.bishoujo.us/renpy/mac.html .
-
-(Linux/Unix)
-
-For information about running Ren'Py games under Linux and Unix,
-please go to http://www.bishoujo.us/renpy/linux.html . At the very
-least, you will need to compile the _renpy module. Read
-the file module/README.txt for details.
-
-
-Playing the Game
-================
-
-By default, the game starts running in full screen mode. On some
-computers, especially some virtual machines, this can lead to mouse
-problems. To fix this, press 'f'.
-
-Some of the more interesting game actions can be performed as follows:
-
-- The left mouse button is used to advance to the next line of
-  dialogue, or to pick menu options.
-
-- The right mouse button brings you into a menu screen where you can
-  save the game, load the game, change preferences, return to the main
-  menu, or quit entirely.
-
-- Scrolling the mouse wheel up or pushing page up returns you to the
-  previous screen.
-
-- Holding down the CTRL key skips dialogue. By default, it only
-  skips read dialogue, but this can be changed by a preference. Tab
-  toggles skip mode.
-

TODO.txt

@@ -1,21 +0,0 @@
-A version of dissolve that only draws the pixels that are being
-dissolved, while doing a straight-blit on pixels that remain the same
-between the two images.
-
-Figure out some way of having variables updated in a new context saved
-permanently, even if we return to the outer context because of a
-rollback or something. Need to be very careful here.
-
-Dynamic variables, parameterized labels, etc.
-
-Implement an extension mechanism of some sort, so that users can drop
-packages of Ren'Py code into the Ren'Py directory, and get stuff like
-speech support.
-
-Implement speech control support.
-
-BPP conversion (perhaps as a package).
-
-Automatically scale to a fixed size.
-
-Hide picture-mouse when leaving window, restore it when entering window.

add.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+
+import argparse
+import os
+import subprocess
+import sys
+
+from renpy import version_tuple #@UnresolvedImport
+
+version = ".".join(str(i) for i in version_tuple)
+short_version = ".".join(str(i) for i in version_tuple[:3])
+print "Version", version
+
+ap = argparse.ArgumentParser()
+
+ap.add_argument("--release", action="store_true")
+ap.add_argument("--prerelease", action="store_true")
+ap.add_argument("--experimental", action="store_true")
+ap.add_argument("--no-tag", "-n", action="store_true")
+
+args = ap.parse_args()
+
+if args.release:
+    links = [ "release", "prerelease", "experimental" ]
+    tag = True
+elif args.prerelease:
+    links = [ "prerelease", "experimental" ]
+    tag = True
+elif args.experimental:
+    links = [ "experimental" ]
+    tag = False
+else:
+    links = [ ]
+    tag = False
+
+
+def check_dirty():
+    if args.no_tag:
+        return
+
+    if subprocess.check_call([ "git", "diff", "--quiet", "HEAD" ]):
+        print "Directory not checked in: {}".format(os.getcwd())
+        sys.exit(1)
+
+os.chdir("/home/tom/ab/renpy")
+check_dirty()
+
+os.chdir("/home/tom/ab/renpy/android")
+check_dirty()
+subprocess.check_call([ "./add_renpy.sh", short_version ])
+
+if not args.no_tag:
+    subprocess.check_call([ "git", "tag", "-a", "rapt-" + version, "-m", "Tagging RAPT release." ])
+
+os.chdir("/home/tom/ab/renpy/dl")
+
+for i in links:
+    if os.path.exists(i):
+        os.unlink(i)
+    os.symlink(short_version, i)
+
+os.chdir("/home/tom/ab/renpy")
+
+if tag and not args.no_tag:
+    cmd = [ "git", "tag", "-a", version, "-m", "Ren'Py " + version ]
+    subprocess.check_call(cmd)
+
+os.chdir("/home/tom/ab/website")
+subprocess.check_call("./upload.sh")

add.sh

@@ -1,13 +0,0 @@
-#!/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

after_checkout.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+ROOT="$(dirname $(python -c "import os;print(os.path.realpath('$0'))"))"
+
+ln -s "$ROOT/help.html" "$ROOT/tutorial/README.html"
+ln -s "$ROOT/help.html" "$ROOT/the_question/README.html"
+ln -s "$ROOT/help.html" "$ROOT/templates/english/README.html"
+
+ln -s "$ROOT/sphinx/source/license.rst" "$ROOT/LICENSE.txt"
+
+if [ "$1" != "" ]; then
+    ln -s "$1/lib" "$ROOT/lib"
+    ln -s "$1/renpy.app" "$ROOT"
+    ln -s "$1/renpy.exe" "$ROOT"
+fi

ansetup.py

@@ -0,0 +1,10 @@
+# This file sets up the normal python modules. It's used to help eclipse
+# do type detection, by providing an importable version of the cython code.
+
+from distutils.core import setup
+
+setup(
+    packages=['renpy', 'renpy.gl', 'renpy.angle', 'renpy.display', 'renpy.audio', 'renpy.text', 'pysdlsound'],
+    package_dir={ 'pysdlsound' : 'module' },
+    )
+

build_exe.bat

@@ -1 +0,0 @@
-build_exe.py run_game

build_exe.py

@@ -1,74 +0,0 @@
-#!/usr/bin/env python
-
-from distutils.core import setup
-import py2exe
-import sys
-import zipfile
-import traceback
-
-# 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')
-
-def main():
-
-    sys.argv[1:] = [ 'py2exe', '--bundle', '2', '-a', '--dll-excludes', 'w9xpopen.exe', ]
-    # sys.argv[1:] = [ 'py2exe', '-a', '--dll-excludes', 'w9xpopen.exe', ]
-
-    setup(name="RenPy",
-          windows=[ dict(script="renpy.py",
-                         dest_base="renpy",
-                         icon_resources=[ (1, "newicon.ico") ] ) ],
-
-          console=[ dict(script="renpy.py", dest_base="console") ],
-
-          zipfile='renpy.code',
-
-          options={ 'py2exe' : { 'excludes' : [ 'doctest',
-                                                'pygame.macosx',
-                                                'pygame.surfarray',
-                                                'pygame.mixer',
-                                                'pygame.mixer_music',
-                                                '_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
-
-        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_styles.py

@@ -1,62 +0,0 @@
-#!/usr/bin/python
-
-import glob
-import os
-
-files = glob.glob("common/*.rpy")
-files.sort()
-
-styles = [ ]
-
-for fn in files:
-    f = file(fn)
-
-    fi = iter(f)
-
-    for l in iter(fi):
-
-        l = l.strip()
-
-        if l.startswith("### "):
-
-            prefix, style, parent = l.split()
-
-            desc = ""
-
-            for l in fi:
-
-                l = l.strip()
-                if not l.startswith("# "):
-                    break
-
-                desc = desc + " " + l[2:]
-
-            styles.append('        style.create("%s", "%s", "%s")' % (style, parent, desc[1:]))
-
-    f.close()
-
-f = file("common/style.rpy")
-of = file("common/style.rpy.new", "w")
-
-fi = iter(f)
-
-for l in fi:
-
-    of.write(l)
-
-    if l.startswith("# AUTOMATICALLY GENERATED"):
-
-        for l in styles:
-            of.write(l + "\n")
-
-        for l in fi:
-            if l.startswith("# END AUTOMATICALLY GENERATED"):
-                break
-
-        of.write(l)
-
-f.close()
-of.close()
-
-os.rename("common/style.rpy", "common/style.rpy.bak")
-os.rename("common/style.rpy.new", "common/style.rpy")

build_translations.py

@@ -1,48 +0,0 @@
-1#!/usr/bin/env python
-
-import glob
-import re
-from sets import Set as set
-import sys
-
-seen_files = set()
-seen_strings = set()
-
-def tl(fn, s):
-
-    s = eval(s)
-
-    if s in seen_strings:
-        return
-
-    if fn not in seen_files:
-        print >>out
-        print >>out, "    # Translatable strings found in", fn
-        print >>out
-        seen_files.add(fn)
-
-    print >>out, "    config.translations[%r] = %r" % (s, s)
-    seen_strings.add(s)
-
-def process(fn):
-    
-    data = file(fn).read()
-
-    for m in re.finditer(r'\bu\"(\\"|[^"])+\"', data):
-        tl(fn, m.group(0))
-
-    for m in re.finditer(r"\bu\'(\\'|[^'])+\'", data):
-        tl(fn, m.group(0))
-
-if __name__ == "__main__":
-
-    # out = file("extras/translations.rpy", "w")
-    out = sys.stdout
-    
-    print >>out, "# This file contains a list of all of the phrases you can translate"
-    print >>out, "# from the Ren'Py common code."
-    print >>out, ""
-    print >>out, "init python:"
-
-    for fn in glob.glob("common/*.rpy") + glob.glob("common/_layout/*.rpym") + glob.glob("common/_compat/*.rpym"):
-        process(fn)

cardgame/game/cardgame.rpy

@@ -1,697 +0,0 @@
-# cardgame.rpy - Cardgame support for Ren'Py
-# Copyright (C) 2008 PyTom <pytom@bishoujo.us>
-#
-# This software may be distributed in modified or unmodified form,
-# provided:
-#
-# (1) This complete license notice is retained.
-#
-# (2) This software and all software and data files distributed
-# alongside this software and intended to be loaded in the same
-# memory space may be redistributed without requirement for
-# payment, notification, or other forms of compensation.
-#
-# 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.
-#
-# Commercial licensing for this software is available, please
-# contact pytom@bishoujo.us for information.
-
-init python:
-
-    import pygame
-    
-    DRAG_NONE = 0
-    DRAG_CARD = 1
-    DRAG_ABOVE = 2
-    DRAG_STACK = 3
-    DRAG_TOP = 4
-
-    # Returns the overlap of the area between the two
-    # rectangles.
-    def __rect_overlap_area(r1, r2):
-        if r1 is None or r2 is None:
-            return 0
-        
-        x1, y1, w1, h1 = r1
-        x2, y2, w2, h2 = r2
-
-        maxleft = max(x1, x2)
-        minright = min(x1 + w1, x2 + w2)
-        maxtop = max(y1, y2)
-        minbottom = min(y1 + h1, y2 + h2)
-
-        if minright < maxleft:
-            return 0
-
-        if minbottom < maxtop:
-            return 0
-
-        return (minright - maxleft) * (minbottom - maxtop)
-
-    def __default_can_drag(table, stack, card):
-        return table.get_faceup(card)
-    
-    class Table(renpy.Displayable):
-
-        def __init__(self, back=None, base=None, springback=0.1, rotate=0.1, can_drag=__default_can_drag, doubleclick=.33, **kwargs):
-
-            renpy.Displayable.__init__(self, **kwargs)
-            
-            # A map from card value to the card object corresponding to
-            # that value.
-            self.cards = { }
-
-            # A list of the stacks that have been defined.
-            self.stacks = [ ]
-
-            # The back of cards that don't have a more specific back
-            # defined.
-            self.back = renpy.easy.displayable_or_none(back)
-
-            # The base of stacks that don't have a more specific base
-            # defined.
-            self.base = renpy.easy.displayable_or_none(base)
-
-            # The amount of time it takes for cards to springback
-            # into their rightful place.
-            self.springback = springback
-
-            # The amount of time it takes for cards to rotate into
-            # their proper orientation.
-            self.rotate = rotate
-
-            # A function that is called to tell if we can drag a
-            # particular card.
-            self.can_drag = can_drag
-
-            # The time between clicks for the click to be considered a
-            # double-click.
-            self.doubleclick = doubleclick
-
-            # Are we sensitive to input? [doc]
-            self.sensitive = True
-            
-            # The last click event.
-            self.last_event = CardEvent()
-            
-            # The card that has been clicked.
-            self.click_card = None
-
-            # The stack that has been clicked.
-            self.click_stack = None
-            
-            # The list of cards that are being dragged.
-            self.drag_cards = [ ]
-            
-            # Are we dragging the cards?
-            self.dragging = False
-            
-            # The position where we clicked.
-            self.click_x = 0
-            self.click_y = 0
-            
-            # The amount of time we've been shown for.
-            self.st = 0
-
-        # This shows the table on the given layer.
-        def show(self, layer='master'):
-
-            for v in self.cards.itervalues():
-                v.offset = __Fixed(0, 0)
-
-            ui.layer(layer)
-            ui.add(self)
-            ui.close()
-
-        # This hides the table.
-        def hide(self, layer='master'):
-            ui.layer(layer)
-            ui.remove(self)
-            ui.close()
-
-        # This controls sensitivity.
-        def set_sensitive(self, value):
-            self.sensitive = value
-            
-        def get_card(self, value):
-            if value not in self.cards:
-                raise Exception("No card has the value %r." % value)
-
-            return self.cards[value]
-            
-        # This sets the faceup status of a card.
-        def set_faceup(self, card, faceup=True):
-            self.get_card(card).faceup = faceup
-            renpy.redraw(self, 0)
-
-        def get_faceup(self, card):
-            return self.get_card(card).faceup
-            
-        # This sets the rotation of a card.
-        def set_rotate(self, card, rotation):
-            __Rotate(self.get_card(card), rotation)
-            renpy.redraw(self, 0)
-
-        def get_rotate(self, card):
-            return self.get_card(card).rotate.rotate_limit()
-            
-        def add_marker(self, card, marker):
-             self.get_card(card).markers.append(marker)
-             renpy.redraw(self, 0)
-
-        def remove_marker(self, card, marker):
-            self.get_card(card).markers.remove(marker)
-            renpy.redraw(self, 0)
-
-        # Called to create a new card.
-        def card(self, value, face, back=None):
-            self.cards[value] = __Card(self, value, face, back)
-
-        # Called to create a new stack.
-        def stack(self, x, y, xoff=0, yoff=0, show=1024, base=None,
-                  click=False, drag=DRAG_NONE, drop=False, hidden=False):
-
-            rv = __Stack(self, x, y, xoff, yoff, show, base, click, drag, drop, hidden) 
-            
-            self.stacks.append(rv)
-            return rv
-
-        # Force a redraw on each interaction.
-        def per_interact(self):
-            renpy.redraw(self, 0)
-
-        
-        def render(self, width, height, st, at):
-
-            self.st = st
-
-            rv = renpy.Render(width, height)
-
-            for s in self.stacks:
-
-                if s.hidden:
-                    s.rect = None
-                    for c in s.cards:
-                        c.rect = None
-                    continue
-
-                s.render_to(rv, width, height, st, at)
-                
-                for c in s.cards:
-                    c.render_to(rv, width, height, st, at)
-            
-            return rv
-
-        def event(self, ev, x, y, st):
-
-            self.st = st
-
-            if not self.sensitive:
-                return
-
-            grabbed = renpy.display.focus.get_grab()
-
-            if (grabbed is not None) and (grabbed is not self):
-                return
-            
-            if ev.type == pygame.MOUSEBUTTONDOWN and ev.button == 1:
-
-                if self.click_stack:
-                    return
-
-                stack = None
-                card = None
-                
-                for s in self.stacks:
-
-                    sx, sy, sw, sh = s.rect
-                    if sx <= x and sy <= y and sx + sw > x and sy + sh > y:
-                        stack = s
-
-
-                    for c in s.cards[-s.show:]:
-                        if c.rect is None:
-                            continue
-
-                        cx, cy, cw, ch = c.rect
-                        if cx <= x and cy <= y and cx + cw > x and cy + ch > y:
-                            card = c
-                            stack = c.stack
-                            
-                if stack is None:
-                    return
-
-                # Grab the display.
-                renpy.display.focus.set_grab(self)
-                
-                # Don't let the user grab a moving card.
-                if card is not None:
-                    xoffset, yoffset = card.offset.offset()
-                    if xoffset or yoffset:
-                        return
-                    
-                # Move the stack containing the card to the front.
-                self.stacks.remove(stack)
-                self.stacks.append(stack)
-                
-                if stack.click or stack.drag:
-                    self.click_card = card
-                    self.click_stack = stack
-                
-                if card is None or not self.can_drag(self, card.stack, card.value):
-                    self.drag_cards = [ ]
-                elif card.stack.drag == DRAG_CARD:
-                    self.drag_cards = [ card ]
-                elif card.stack.drag == DRAG_ABOVE:
-                    self.drag_cards = [ ]
-                    for c in card.stack.cards:
-                        if c is card or self.drag_cards:
-                            self.drag_cards.append(c)
-                elif card.stack.drag == DRAG_STACK:
-                    self.drag_cards = list(card.stack.cards)
-                elif card.stack.drag == DRAG_TOP:
-                    if card.stack.cards[-1] is card:
-                        self.drag_cards = [ card ]
-                    else:
-                        self.drag_cards = [ ]
-
-                for c in self.drag_cards:
-                    c.offset = __Fixed(0, 0)
-                        
-                self.click_x = x
-                self.click_y = y
-                self.dragging = False
-                
-                renpy.redraw(self, 0)
-                
-                raise renpy.IgnoreEvent()
-
-            if ev.type == pygame.MOUSEMOTION or (ev.type == pygame.MOUSEBUTTONUP and ev.button == 1):
-
-                if abs(x - self.click_x) > 7 or abs(y - self.click_y) > 7:
-                    self.dragging = True
-
-                dx = x - self.click_x
-                dy = y - self.click_y
-
-                for c in self.drag_cards:
-                    xoffset, yoffset = c.offset.offset()
-                    
-                    cdx = dx - xoffset
-                    cdy = dy - yoffset
-
-                    c.offset = __Fixed(dx, dy)
-                    
-                    if c.rect:
-                        cx, cy, cw, ch = c.rect
-                        cx += cdx
-                        cy += cdy
-                        c.rect = (cx, cy, cw, ch)
-
-                area = 0
-                dststack = None 
-                dstcard = None
-                
-                for s in self.stacks:
-                    if not s.drop:
-                        continue
-                    
-                    for c in self.drag_cards:
-
-                        if c.stack == s:
-                            continue
-                        a = __rect_overlap_area(c.rect, s.rect)
-                        if a >= area:
-                            dststack = s
-                            dstcard = None
-                            area = a
-                            
-                        for c1 in s.cards:
-                            a = __rect_overlap_area(c.rect, c1.rect)
-                            if a >= area:
-                                dststack = s
-                                dstcard = c1
-                                area = a
-
-                if area == 0:
-                    dststack = None
-                    dstcard = None
-
-                renpy.redraw(self, 0)
-
-                if ev.type == pygame.MOUSEMOTION:
-                    raise renpy.IgnoreEvent()
-
-            if ev.type == pygame.MOUSEBUTTONUP and ev.button == 1:
-
-                # Ungrab the display.
-                renpy.display.focus.set_grab(None)
-
-                evt = None
-
-                if self.dragging:
-                    if dststack is not None and self.drag_cards:
-
-                        evt = CardEvent()
-                        evt.type = "drag"
-                        evt.table = self
-                        evt.stack = self.click_stack
-                        evt.card = self.click_card.value
-                        evt.drag_cards = [c.value for c in self.drag_cards]
-                        evt.drop_stack = dststack
-                        if dstcard:
-                            evt.drop_card = dstcard.value
-                        evt.time = st
-                            
-                else:
-
-                    if self.click_stack.click:                    
-
-                        evt = CardEvent()
-                        evt.type = "click"
-                        evt.table = self
-                        evt.stack = self.click_stack
-                        if self.click_card:
-                            evt.card = self.click_card.value
-                        else:
-                            evt.card = None
-
-                        evt.time = st
-
-                        if (evt.type == self.last_event.type
-                            and evt.stack == self.last_event.stack
-                            and evt.card == self.last_event.card
-                            and evt.time < self.last_event.time + self.doubleclick):
-
-                            evt.type = "doubleclick"
-
-                if evt is not None:
-                    self.last_event = evt
-                        
-                for c in self.drag_cards:
-                    c.springback()
-                    
-                self.click_card = None
-                self.click_stack = None
-                self.drag_cards = [ ]
-
-                if evt is not None: 
-                    return evt
-                else:
-                    raise renpy.IgnoreEvent()
-
-                
-    class CardEvent(object):
-
-        def __init__(self):
-            self.type = None
-            self.stack = None
-            self.card = None
-            self.drag_cards = None
-            self.drop_stack = None
-            self.drop_card = None
-            self.time = 0
-            
-    # Represents a stack of one or more cards, which can be placed on the
-    # table.
-    class __Stack(object):
-
-        def __init__(
-            self, table,
-            x, y,
-            xoff, yoff,
-            show, base,
-            click, drag, drop,
-            hidden):
-
-
-            # The table this stack belongs to.
-            self.table = table
-
-            # The x and y coordinates of the center of the top card of
-            # this stack.
-            self.x = x
-            self.y = y
-
-            # The offset in the x and y directions of each successive
-            # card.
-            self.xoff = xoff
-            self.yoff = yoff
-
-            # The number of cards to show from this stack. (We show the
-            # last show cards if this is less than the numebr of cards
-            # in the stack.)
-            self.show = show
-
-            # The image that is shown behind the stack. If None, the
-            # background is taken from the table.
-            self.base = base
-
-            # Should we report click events on this stack?
-            self.click = click
-
-            # Should we allow dragging this stack? If so, how?
-            self.drag = drag
-
-            # Should we allow dropping to this stack?
-            self.drop = drop
-
-            # Is this stack hidden?
-            self.hidden = hidden
-            
-            # The list of cards in this stack.
-            self.cards = [ ]
-
-            # The rectangle for the background of this effect.
-            self.rect = None
-            
-        def insert(self, index, card):
-            card = self.table.get_card(card)
-
-            if card.stack:
-                card.stack.cards.remove(card)
-
-            card.stack = self
-            self.cards.insert(index, card)
-
-            self.table.stacks.remove(self)
-            self.table.stacks.append(self)
-            
-            card.springback()
-            
-        def append(self, card):
-            if card in self.cards:                
-                self.insert(len(self.cards) - 1, card)
-            else:
-                self.insert(len(self.cards), card)
-
-        def remove(self, card):
-            card = self.table.get_card(card)            
-            self.cards.remove(card)
-            card.stack = None
-            card.rect = None
-
-        def deal(self):
-            if not self.cards:
-                return None
-                
-            card = self.cards[-1]
-            self.remove(card.value)
-            return card.value
-
-        def shuffle(self):
-            renpy.random.shuffle(self.cards)
-            renpy.redraw(self.table, 0)
-            
-        def __len__(self):
-            return len(self.cards)
-
-        def __getitem__(self, idx):
-            return self.cards[idx].value
-
-        def __iter__(self):
-            for i in self.cards:
-                yield i.value
-
-        def __contains__(self, item):
-            return self.table.get_card(card) in self.cards
-                
-        def render_to(self, rv, width, height, st, at):
-
-            base = self.base or self.table.base
-
-            if base is None:
-                return
-
-            surf = renpy.render(base, width, height, st, at)
-            cw, ch = surf.get_size()
-
-            cx = self.x - cw / 2
-            cy = self.y - ch / 2
-
-            self.rect = (cx, cy, cw, ch)
-            rv.blit(surf, (cx, cy))
-            
-    class __Card(object):
-
-        def __init__(self, table, value, face, back):
-
-            # The table this card belongs to.
-            self.table = table
-
-            # The value of this card.
-            self.value = value
-
-            # The face of this card.
-            self.face = renpy.easy.displayable(face)
-
-            # The back of this card. If None, then the back is taken from
-            # the table the card belongs to.
-            self.back = renpy.easy.displayable_or_none(back)
-
-            # Is this card faceup (or face down?)
-            self.faceup = True
-
-            # Object that's called to decide how rotated this card should
-            # be.
-            self.rotate = None
-
-            # A series of highlights that should be drawn over this card.
-            self.highlights = [ ]
-
-            # The stack this card is in.
-            self.stack = None
-
-            # An object that gives the offset of this card relative to
-            # where it would normally be placed.
-            self.offset = __Fixed(0, 0)
-            
-            # The rectangle where this card was last drawn to the screen
-            # at.
-            self.rect = None
-
-            __Rotate(self, 0)
-            
-        # Returns the base x and y placement of this card.
-        def place(self):
-            s = self.stack
-            offset = max(len(s.cards) - s.show, 0)
-            index = max(s.cards.index(self) - offset, 0)
-
-            return (s.x + s.xoff * index, s.y + s.yoff * index)
-
-        def springback(self):
-            if self.rect is None:
-                self.offset = __Fixed(0, 0)
-            else:
-                self.offset = __Springback(self)
-                        
-        def render_to(self, rv, width, height, st, at):
-            
-            x, y = self.place()
-            xoffset, yoffset = self.offset.offset()
-            x += xoffset
-            y += yoffset
-
-            if self.faceup:
-                d = self.face
-            else:
-                d = self.back or self.table.back
-                
-            # TODO: Figure out if we can reuse some of this.
-
-            if self.highlights:
-                d = Fixed(* ([d] + [renpy.easy.displayable(i) for i in self.highlights]))
-
-            r = self.rotate.rotate()
-            if r:
-                d = RotoZoom(r, r, 0, 1, 1, 0)(d)
-                
-            surf = renpy.render(d, width, height, st, at)
-            w, h = surf.get_size()
-
-            x -= w / 2
-            y -= h / 2
-
-            self.rect = (x, y, w, h)
-
-            rv.blit(surf, (x, y))
-            
-        def __repr__(self):
-            return "<__Card %r>" % self.value
-        
-
-    class __Springback(object):
-
-        def __init__(self, card):
-            self.card = card
-            self.table = table = card.table
-            
-            self.start = table.st
-
-            cx, cy, cw, ch = self.card.rect
-            x = cx + cw / 2
-            y = cy + ch / 2
-
-            self.startx = x
-            self.starty = y
-
-        def offset(self):
-
-            t = (self.table.st - self.start) / self.table.springback
-            t = min(t, 1.0)
-            
-            if t < 1.0:
-                renpy.redraw(self.table, 0)
-
-            px, py = self.card.place() 
-                
-            return int((self.startx - px) * (1.0 - t)), int((self.starty - py) * (1.0 - t))
-
-
-    class __Fixed(object):
-        def __init__(self, x, y):
-            self.x = x
-            self.y = y
-
-        def offset(self):
-            return self.x, self.y
-        
-
-    class __Rotate(object):
-        def __init__(self, card, amount):
-
-            self.table = table = card.table
-            self.start = table.st
-            
-            if card.rotate is None:
-                self.start_rotate = amount
-            else:
-                self.start_rotate = card.rotate.rotate()
-
-            self.end_rotate = amount
-
-            card.rotate = self
-
-            
-        def rotate(self):
-
-            if self.start_rotate == self.end_rotate:
-                return self.start_rotate
-
-            t = (self.table.st - self.start) / self.table.springback
-            t = min(t, 1.0)
-
-            if t < 1.0:
-                renpy.redraw(self.table, 0)
-
-            return self.start_rotate + (self.end_rotate - self.start_rotate) * t
-        
-        def rotate_limit(self):
-            return self.end_rotate

cardgame/game/klondike.rpy

@@ -1,336 +0,0 @@
-# klondike.rpy - Klondike Solitaire
-# Copyright (C) 2008 PyTom <pytom@bishoujo.us>
-#
-# This software may be distributed in modified or unmodified form,
-# provided:
-#
-# (1) This complete license notice is retained.
-#
-# (2) This software and all software and data files distributed
-# alongside this software and intended to be loaded in the same
-# memory space may be redistributed without requirement for
-# payment, notification, or other forms of compensation.
-#
-# 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.
-#
-# Commercial licensing for this software is available, please
-# contact pytom@bishoujo.us for information.
-
-init python:
-
-    class Klondike(object):
-
-        # We represent a card as a (suit, rank) tuple. The suit is one of the
-        # following four constants, while the rank is 1 for ace, 2 for 2,
-        # ..., 10 for 10, 11 for jack, 12 for queen, 13 for king.        
-        CLUB = 0
-        SPADE = 1
-        HEART = 2
-        DIAMOND = 3
-        
-        def __init__(self, deal=3):
-
-            # Constants that let us easily change where the game is
-            # located.
-            LEFT=140
-            TOP=58
-            COL_SPACING = 90
-            ROW_SPACING = 120
-            CARD_XSPACING = 20
-            CARD_YSPACING = 30
-
-            # Store the parameters.
-            self.deal = deal
-            
-            # Create the table, stock, and waste.
-            self.table = t = Table(base="card/base.png", back="card/back.png")
-            self.stock = t.stack(LEFT, TOP, xoff=0, yoff=0, click=True)
-            self.waste = t.stack(LEFT + COL_SPACING, TOP, xoff=CARD_XSPACING, drag=DRAG_TOP, show=self.deal, click=True)
-
-            # The 4 foundation stacks.
-            self.foundations = [ ]
-            for i in range(0, 4):
-                s = t.stack(LEFT + COL_SPACING * (i + 3), TOP, xoff=0, yoff=0, drag=DRAG_TOP, drop=True)
-                self.foundations.append(s)
-
-            # The 7 tableau stacks.
-            self.tableau = [ ]
-            for i in range(0, 7):
-                s = t.stack(LEFT + COL_SPACING * i, TOP + ROW_SPACING, xoff=0, yoff=CARD_YSPACING, drag=DRAG_ABOVE, click=True, drop=True)
-                self.tableau.append(s)
-
-            # Create the stock and shuffle it.
-            for rank in range(1, 14):
-                for suit in range(0, 4):
-                    value = (suit, rank)
-                    t.card(value, "card/%d.png" % self.card_num(suit, rank))
-                    t.set_faceup(value, False)
-                    self.stock.append(value)
-                    
-            self.stock.shuffle()
-            
-            # Deal out the initial tableau.
-            for i in range(0, 7):
-                for j in range(i, 7):
-                    c = self.stock.deal()
-                    self.tableau[j].append(c)                    
-
-            # Ensure that the bottom of each tableau is faceup.
-            for i in range(0, 7):
-                if self.tableau[i]:
-                    self.table.set_faceup(self.tableau[i][-1], True)
-
-
-        # This figures out the image filename for a given suit and rank.
-        def card_num(self, suit, rank):
-            ranks = [ None, 1, 49, 45, 41, 37, 33, 29, 25, 21, 17, 13, 9, 5 ]
-            return suit + ranks[rank]
-                
-        def show(self):
-            self.table.show()
-
-        def hide(self):
-            self.table.hide()
-            
-        def tableau_drag(self, evt):
-
-            card = evt.drag_cards[0]
-            cards = evt.drag_cards
-            stack = evt.drop_stack
-
-            csuit, crank = card
-            
-            # If the stack is empty, allow a king to be dragged to it.
-            if not stack:
-                if crank == 13:
-                    for i in cards:
-                        stack.append(i)
-
-                return "tableau_drag"
-
-            # Otherwise, the stack has a bottom card.
-            bottom = stack[-1]
-            bsuit, brank = bottom
-
-            # Figure out which of the stacks are black.
-            cblack = (csuit == self.SPADE) or (csuit == self.CLUB)
-            bblack = (bsuit == self.SPADE) or (bsuit == self.CLUB)
-
-            # Can we legally place the cards?
-            if (bblack != cblack) and (crank == brank - 1):
-
-                # Place the cards:
-                for i in cards:
-                    stack.append(i)
-
-                return "tableau_drag"
-
-            return False
-                    
-        def foundation_drag(self, evt):
-
-            # We can only drag one card at a time to a foundation.
-            if len(evt.drag_cards) != 1:
-                return False
-
-            suit, rank = evt.drag_cards[0]
-
-            # If there is a card on the foundation already, then
-            # check to see if we're dropping then next one in
-            # sequence.
-            if len(evt.drop_stack):
-                dsuit, drank = evt.drop_stack[-1]
-                if suit == dsuit and rank == drank + 1:
-                    evt.drop_stack.append(evt.drag_cards[0])
-                    return "foundation_drag"
-                    
-            # Otherwise, make sure we're dropping an ace.
-            else:
-                if rank == 1:
-                    evt.drop_stack.append(evt.drag_cards[0])
-                    return "foundation_drag"
-
-            return False
-                
-        def tableau_doubleclick(self, evt):
-
-            # Make sure that there's at least one card in the stack.
-            if not evt.stack:
-                return False
-
-            # The bottom card in the stack.
-            card = evt.stack[-1]
-            suit, rank = card
-
-            # If the card is an ace, find an open foundation and put it
-            # there.
-            if rank == 1:
-                for i in self.foundations:
-                    if not i:
-                        i.append(card)
-                        break
-                return "foundation_drag"
-
-            # Otherwise, see if there's a foundation where we can put
-            # the card.
-            for i in self.foundations:
-                if not i:
-                    continue
-                
-                fsuit, frank = i[-1]
-                if suit == fsuit and rank == frank + 1:
-                    i.append(card)
-                    return "foundation_drag"
-
-            return False
-        
-        def stock_click(self, evt):
-
-            # If there are cards in the stock, dispense up to three3
-            # of them.
-            if self.stock:
-                for i in range(0, self.deal):
-                    if self.stock:
-                        c = self.stock[-1]
-                        self.table.set_faceup(c, True)
-                        self.waste.append(c)
-
-                return "stock_click"
-                        
-            # Otherwise, move the contents of the waste to the stock.
-            else:
-                while self.waste:
-                    c = self.waste[-1]
-                    self.table.set_faceup(c, False)
-                    self.stock.append(c)
-
-                return "stock_click"
-
-                    
-        def interact(self):
-
-            evt = ui.interact()
-            rv = False
-            
-            # Check the various events, and dispatch them to the methods
-            # that handle them.
-            if evt.type == "drag":
-                if evt.drop_stack in self.tableau:
-                    rv = self.tableau_drag(evt)
-                    
-                elif evt.drop_stack in self.foundations:
-                    rv = self.foundation_drag(evt)
-                    
-            elif evt.type == "click":
-                if evt.stack == self.stock:
-                    rv = self.stock_click(evt)
-                    
-            elif evt.type == "doubleclick":
-                if (evt.stack in self.tableau) or (evt.stack is self.waste):
-                    rv = self.tableau_doubleclick(evt)
-                    
-            # Ensure that the bottom card in each tableau is faceup.
-            for i in range(0, 7):
-                if self.tableau[i]:
-                    self.table.set_faceup(self.tableau[i][-1], True)
-
-            # Check to see if any of the foundations has less than
-            # 13 cards in it. If it does, return False. Otherwise,
-            # return True.
-            for i in self.foundations:
-                if len(i) != 13:
-                    return rv
-
-            return "win"
-
-        # Sets things as sensitive (or not).
-        def set_sensitive(self, value):
-            self.table.set_sensitive(value)
-        
-        # Utility functions.
-
-        # Is it okay to drag the over card onto under, where under is
-        # part of a tableau.
-        def can_hint(self, under, over):
-            usuit, urank = under
-            osuit, orank = over
-
-            if orank == 1:
-                return False
-            
-            ublack = (usuit == self.SPADE) or (usuit == self.CLUB)
-            oblack = (osuit == self.SPADE) or (osuit == self.CLUB)
-
-            if (oblack != ublack) and (orank == urank - 1):
-                return True
-
-        # Returns the first faceup card in the stack.
-        def first_faceup(self, s):
-            for c in s:
-                if self.table.get_faceup(c):
-                    return c
-
-        # This tries to find a reasonable hint, and returns it as a
-        # pair of cardnames.
-        def hint(self):
-
-            for i in self.tableau:
-                if not i:
-                    continue
-
-                over = self.first_faceup(i)
-
-                for j in self.tableau:
-                    if not j or i is j:
-                        continue
-
-                    under = j[-1]
-
-                    if self.can_hint(under, over):
-                        return (under, over)
-
-            if self.waste:
-
-                over = self.waste[-1]
-
-                for j in self.tableau:
-                    if not j:
-                        continue
-
-                    under = j[-1]
-
-                    if self.can_hint(under, over):
-                        return (under, over)
-                
-            return None, None
-            
-        def card_name(self, c):
-            suit, rank = c
-
-            return  [
-                "INVALID",
-                "Ace",
-                "Two",
-                "Three",
-                "four",
-                "Five",
-                "Six",
-                "Seven",
-                "Eight",
-                "Nine",
-                "Ten",
-                "Jack",
-                "Queen",
-                "King" ][rank] + " of " + [
-                "Clubs",
-                "Spades",
-                "Hearts",
-                "Diamonds" ][suit]
-                     
-                    

cardgame/game/options.rpy

@@ -1,247 +0,0 @@
-## 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"Ren'Py Cardgame Demo"
-
-    #########################################
-    # 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 = "#7AA27B",
-
-        ## The color of a focused widget face.
-        widget_hover = "#A3C7A3",
-
-        ## The color of the text in a widget.
-        widget_text = "#CDE0CE",
-
-        ## The color of the text in a selected widget. (For
-        ## example, the current value of a preference.)
-        widget_selected = "#ffffff",
-
-        ## The color of a disabled widget face. 
-        disabled = "#426143",
-
-        ## The color of disabled widget text.
-        disabled_text = "#819981",
-
-        ## The color of informational labels.
-        label = "#ffffff",
-
-        ## The color of a frame containing widgets.
-        frame = "#245536",
-
-        ## 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 = "mainmenu.jpg",
-
-        ## 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 = "table.jpg",
-
-        ## 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.            
-        )
-
-
-    #########################################
-    ## 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 = dissolve
-
-    ## Used when exiting the game menu to the game.
-
-    config.exit_transition = dissolve
-
-    ## Used between screens of the game menu.
-
-    config.intra_transition = dissolve
-
-    ## Used when entering the game menu from the main menu.
-
-    config.main_game_transition = dissolve
-
-    ## Used when returning to the main menu from the game.
-
-    config.game_main_transition = dissolve
-
-    ## Used when entering the main menu from the splashscreen.
-
-    config.end_splash_transition = dissolve
-
-    ## Used when entering the main menu after the game has ended.
-
-    config.end_game_transition = fade
-
-    ## Used when a game is loaded.
-
-    config.after_load_transition = dissolve
-
-    
-    #########################################
-    ## 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
-
-    config.save_directory = "cardgame-11754"
-    

cardgame/game/script.rpy

@@ -1,184 +0,0 @@
-# You can place the script of your game in this file.
-
-init:
-    $ e = Character('Eileen', color="#c8ffc8")
-
-    image eileen happy = "eileen_happy.png"
-    image bg table = "table.jpg"
-    image dim = "#0008"
-
-    # Some styles for show text.
-    $ style.centered_text.drop_shadow = (2, 2)
-    $ style.centered_text.drop_shadow_color = "#000b"
-
-label start:
-
-    scene bg table
-
-    python:
-        k = Klondike(1)
-        k.set_sensitive(False)
-        k.show()
-
-    show dim
-    show eileen happy
-    with dissolve
-    
-    e "Welcome to the cardgame demo. Let's play some solitaire!"
-
-    e "I might show up from time to time to give you some advice, but it's up to you if you want to take it."
-
-    e "Good luck!"
-
-label continue:
-
-    hide dim
-    hide eileen
-    with dissolve
-
-label quick_continue:
-    
-    $ hint_count = renpy.random.randint(10, 20)
-    
-    while True:
-
-        python:
-        
-            ui.textbutton("Give Up", ui.jumps("giveup"), xalign=.02, yalign=.98)
-            k.set_sensitive(True)
-            event = k.interact()
-
-            if event:
-                renpy.checkpoint()
-            
-        if event == "win":
-            jump win
-
-        if event == "tableau_drag" or event == "stock_click":
-            $ hint_count -= 1
-            if hint_count <= 0:
-                jump hint
-
-label win:
-
-    show dim
-    show eileen happy
-    with dissolve
-    
-    "Congratulations!"
-
-    jump newgame
-
-label giveup:
-
-    $ k.set_sensitive(False)
-    
-    show dim
-    show eileen happy
-    with dissolve
-    
-    menu:
-        e "Are you sure you want to give up?"
-
-        "Yes":
-
-            "Oh well, better luck next time."
-            
-            jump newgame
-
-        "No":
-
-            jump continue
-
-label newgame:
-
-    menu:    
-        e "Would you like to try again?"
-
-        "Yes":
-            pass
-
-        "No":
-            e "Well, I hope to see you again soon."
-            return 
-
-    e "Okay, here we go!"
-    
-    scene bg table
-
-    python:
-        k = Klondike(1)
-        k.sensitive = False
-        k.show()
-
-    jump continue
-    
-
-label hint:
-
-    $ under, over = k.hint()
-
-    $ print under, over
-
-    if under is None:
-        jump quick_continue
-        
-    $ under = k.card_name(under)
-    $ over = k.card_name(over)
-    
-    $ k.set_sensitive(False)
-
-    show dim
-    show eileen happy
-    with dissolve
-
-    $ hint = renpy.random.randint(0, 2)
-
-    if hint == 0:
-        e "Maybe put the %(over)s on top of the %(under)s."
-
-    elif hint == 1:
-        e "You can try moving the %(over)s to the %(under)s."
-
-    elif hint == 2:
-        e "I think something can go on the %(under)s."
-    
-    jump continue
-
-
-# This has nothing to do with card games.
-label splashscreen:
-
-    scene bg table
-    $ renpy.pause(1.0)
-    
-    show text "According to legend, prospectors in the klondike would carry with them a deck of cards."
-    with dissolve
-    with Pause(5.0)
-    hide text
-    with dissolve
-    with Pause(1.0)
-    
-    show text "If they were ever lost, they'd start playing a game of solitaire."
-    with dissolve
-    with Pause(4.0)
-    hide text
-    with dissolve
-    with Pause(1.0)
-
-    show text "Without fail, help would soon arrive..."
-    with dissolve
-    with Pause(3.0)
-    hide text
-    with dissolve
-    with Pause(1.0)
-
-    show text "... saying \"put the Five of Spades on the Six of Hearts.\""
-
-    with dissolve
-    with Pause(4.0)
-    hide text
-    with dissolve
-    with Pause(1.0)
-    
-    return

common/00compat.rpy

@@ -1,64 +0,0 @@
-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()
-
-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 "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

@@ -1,158 +0,0 @@
-# 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 python:
-
-    _define = define = object()
-        
-    # Positions ##############################################################
-
-    # 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(xalign=0.0)
-    center = Position(xalign=0.5)
-    truecenter = Position(xalign=0.5, yalign=0.5)
-    right = Position(xalign=1.0)
-
-    # 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.    
-    offscreenleft = Position(xpos=0.0, xanchor=1.0)
-    offscreenright = Position(xpos=1.0, xanchor=0.0)
-
-    # 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):
-        moves = {
-            "" : MoveTransition(
-                delay,
-                old=old,
-                factory=MoveFactory(time_warp=time_warp)),
-
-            "inright" : MoveTransition(
-                delay,
-                old=old,
-                factory=MoveFactory(time_warp=time_warp), 
-                enter_factory=MoveIn((1.0, None, 0.0, None), time_warp=in_time_warp)),
-
-            "inleft" : MoveTransition(
-                delay,
-                old=old,
-                factory=MoveFactory(time_warp=time_warp), 
-                enter_factory=MoveIn((0.0, None, 1.0, None), time_warp=in_time_warp)),
-
-            "intop" : MoveTransition(
-                delay,
-                old=old,
-                factory=MoveFactory(time_warp=time_warp), 
-                enter_factory=MoveIn((None, 0.0, None, 1.0), time_warp=in_time_warp)),
-
-            "inbottom" : MoveTransition(
-                delay,
-                old=old,
-                factory=MoveFactory(time_warp=time_warp), 
-                enter_factory=MoveIn((None, 1.0, None, 0.0), time_warp=in_time_warp)),
-
-            "outright" : MoveTransition(
-                delay,
-                old=old,
-                factory=MoveFactory(time_warp=time_warp), 
-                leave_factory=MoveOut((1.0, None, 0.0, None), time_warp=out_time_warp)),
-
-            "outleft" : MoveTransition(
-                delay,
-                old=old,
-                factory=MoveFactory(time_warp=time_warp), 
-                leave_factory=MoveOut((0.0, None, 1.0, None), time_warp=out_time_warp)),
-
-            "outtop" : MoveTransition(
-                delay,
-                old=old,
-                factory=MoveFactory(time_warp=time_warp), 
-                leave_factory=MoveOut((None, 0.0, None, 1.0), time_warp=out_time_warp)),
-
-            "outbottom" : MoveTransition(
-                delay,
-                old=old,
-                factory=MoveFactory(time_warp=time_warp), 
-                leave_factory=MoveOut((None, 1.0, None, 0.0), time_warp=time_warp)),
-            }
-
-        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")

common/00developer.rpy

@@ -1,217 +0,0 @@
-# Entry point for the developer console.
-label _developer:
-
-    if not config.developer:
-        return
-
-    call _enter_menu from _call__enter_menu_4
-
-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("Return", None, clicked=ui.returns(True), size_group=sg)
-        layout.button("Reload Game (Shift+R)", None, clicked=ui.callsinnewcontext("_save_reload_game"), size_group=sg)
-        layout.button("Variable Viewer", None, clicked=ui.jumps("_debugger_screen"), size_group=sg)
-        layout.button("Theme Test", None, clicked=ui.jumps("_theme_test"), size_group=sg)
-        layout.button("Style Hierarchy", None, clicked=ui.jumps("_style_hierarchy"), 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:
-    
-    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
-        
-        

common/00library.rpy

@@ -1,711 +0,0 @@
-# Copyright 2004-2007 PyTom
-#
-# Please see the LICENSE.txt distributed with Ren'Py for permission to
-# copy and modify.
-
-# 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        
-
-    # 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
-
-    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()
-    
-init -1180 python hide:
-
-    # Called to make a screenshot happen.
-    def screenshot():
-        import os.path
-
-        i = 1
-        while True:
-            fn = "screenshot%04d.png" % i
-            if not os.path.exists(fn):
-                break
-            i += 1
-
-        renpy.screenshot(fn)
-
-    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.
-    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"),
-        )
-
-    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)
-        _windows_hidden = False
-
-    return
-
-    
-# This code here handles check for the correct version of the Ren'Py module.
-
-label _check_module:
-
-    if not config.module_warning:
-        return
-
-    python hide:
-        module_info = _(u"While Ren'Py games may be playable without the renpy module, some features may be disabled. For more information, read the module/README.txt file or go to http://www.bishoujo.us/renpy/.")
-
-        if renpy.module_version() == 0:
-            _show_exception(_(u"renpy module not found."),
-                            _(u"The renpy module could not be loaded on your system.") + "\n\n" + module_info)
-        elif renpy.module_version() < config.module_version:
-            _show_exception(_(u"Old renpy module found."),
-                            _(u"An old version (%d) of the Ren'Py module was found on your system, while this game requires version %d.") % (renpy.module_version(), config.module_version) + "\n\n" + module_info)
-
-    return
-    
-
-                         
-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")
-
-        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()
-        renpy.take_screenshot((config.thumbnail_width, config.thumbnail_height))
-
-        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")
-
-        store.main_menu = False
-        store._window_subtitle = config.menu_window_subtitle
-        
-        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
-
-    $ 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 _check_module from _call__check_module_1
-    call _load_reload_game from _call__load_reload_game_1
-
-    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()
-
-    python hide:
-        for i in range(0, 7):
-            # renpy.music.stop(channel=i)
-            # renpy.sound.stop(channel=i)
-            pass
-            
-    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
-
-    if _restart is None:
-        $ renpy.transition(config.end_splash_transition)
-    else:
-        $ renpy.transition(_restart[0])
-        jump expression _restart[1]
-        
-label _invoke_main_menu:
-        
-    $ renpy.call_in_new_context("_enter_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 _enter_main_menu:
-
-    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
-        
-# This is called to show the main menu to the user.
-label _main_menu:    
-
-    # 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

common/00menus.rpy

@@ -1,42 +0,0 @@
-# Copyright 2008 PyTom
-#
-# Please see the LICENSE.txt distributed with Ren'Py for permission to
-# copy and modify.
-
-# 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"Continue Game", _intra_jumps("load_screen", "main_game_transition"), "True"),
-        (u"Preferences", _intra_jumps("preferences_screen", "main_game_transition"), "True"),
-        (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' ),
-        ( None, u"Quit", ui.callsinnewcontext("_quit_prompt"), 'True' ),
-        ]
-
-label _quit_prompt:
-    if layout.yesno_prompt(None, u"Are you sure you want to quit?"):
-        jump _quit
-    else:
-        return
-
-label _main_menu_prompt:
-    if layout.yesno_prompt(None, u"Are you sure you want to return to the main menu?\nThis will lose unsaved progress."):
-        $ renpy.full_restart(transition=config.game_main_transition)
-    else:
-        return
-
-    
- 

common/00statements.rpy

@@ -1,266 +0,0 @@
-# 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
-        
-        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
-                    
-            renpy.error('could not parse statement.')
-
-        return dict(file=file,
-                    fadeout=fadeout,
-                    fadein=fadein,
-                    channel=channel)
-
-    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)
-
-    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
-            
-        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")
-
-        return dict(file=file, channel=channel)
-
-    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)
-
-
-    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)
-
-    
-                              
-init -1200 python:
-
-    def _try_eval(e, what):
-        try:
-            return eval(e)
-        except:
-            renpy.error('unable to evaluate %s %r' % (what, e))
-    

common/00themes.rpy

@@ -1,719 +0,0 @@
-# Copyright 2004-2008 PyTom
-#
-# Please see the LICENSE.txt distributed with Ren'Py for permission to
-# copy and modify.
-
-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 = True,
-        rounded_window = True,
-        outline_bars = False,
-
-        mm_root = None,
-        gm_root = None):
-
-        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.outline_drop_shadow = [
-        (0, -2),
-        (-1, -1), (0, -1), (1, -1),
-        (-2, 0), (-1, 0), (1, 0), (2, 0),
-        (-1, 1), (0, 1), (1, 1),
-        (0, 2)
-        ]
-
-    @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.drop_shadow = theme.outline_drop_shadow
-        style.button_text.drop_shadow_color = idle
-        style.button_text.hover_drop_shadow_color = hover
-        style.button_text.selected_drop_shadow_color = selected
-        style.button_text.selected_hover_drop_shadow_color = hover
-        style.button_text.insensitive_drop_shadow_color = 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.drop_shadow = theme.outline_drop_shadow
-        style.large_button_text.drop_shadow_color = idle
-        style.large_button_text.hover_drop_shadow_color = hover
-        style.large_button_text.selected_drop_shadow_color = selected
-        style.large_button_text.selected_hover_drop_shadow_color = hover
-        style.large_button_text.insensitive_drop_shadow_color = insensitive
-        
-    @theme
-    def outline_prompts(
-        inside,
-        prompt,
-        text_size):
-
-        theme.clear_prompts()
-        
-        style.prompt_text.color = inside
-        style.prompt_text.drop_shadow = theme.outline_drop_shadow
-        style.prompt_text.drop_shadow_color = 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.drop_shadow = theme.outline_drop_shadow
-        style.label_text.drop_shadow_color = 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

@@ -1,116 +0,0 @@
-# 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
-
-        # 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
-
-    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)
-            elif not _voice.sustain:
-                renpy.sound.stop(channel=2)
-
-            _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/_layout/imagemap_common.rpym

@@ -1,79 +0,0 @@
-init python:
-    
-    class _ImageMapper(object):
-
-        def __init__(self, ground, idle, hover, selected_idle, selected_hover, hotspots):
-
-            self.idle = idle
-            self.hover = hover
-            self.selected_idle = selected_idle
-            self.selected_hover = selected_hover
-            
-            self.hotspots = { }
-            for (x1, y1, x2, y2, name) in hotspots:
-                self.hotspots[name] = (x1, y1, x2, y2)
-
-            ui.fixed(style='imagemap')
-            ui.image(ground)
-            
-
-        def button(self, name, clicked, selected):
-
-            if name not in self.hotspots:
-                return None
-
-            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.selected_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',
-                )
-
-            return (x1, y1, x2, y2)
-
-            
-        def bar(self, name, range, value, changed):
-
-            if name not in self.hotspots:
-                return
-
-            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 close(self):
-            ui.close()

common/_layout/imagemap_main_menu.rpym

@@ -1,52 +0,0 @@
-init python:
-
-    layout.provides('main_menu')
-    
-    # The ground image.
-    config.main_menu_ground = None
-
-    # The selected image.
-    config.main_menu_selected = 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.
-    # - 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 = [ ]
-    
-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()
-        
-        rv = renpy.imagemap(
-            config.main_menu_ground,
-            config.main_menu_selected,
-            config.main_menu_hotspots)
-
-        for e in config.main_menu:
-            name = e[0]
-            act = e[1]
-            enable = e[2]
-            
-            if name == rv:
-
-                if isinstance(act, basestring):
-                    act = ui.jumpsoutofcontext(act)
-                act()
-        else:
-            ui.jumpsoutofcontext(rv)()
-
-
-            
-    

common/_layout/scrolling_load_save.rpym

@@ -1,224 +0,0 @@
-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):
-
-        @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(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 "")
-                
-                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:
-            rv = ui.interact()
-        finally:
-            __session.scrollbar_position = adj.value
-            __session.thumbnail = None
-
-        return rv
-        
-        
-label save_screen:
-
-    python hide:
-        while True:
-            fn = _file_picker("save")
-
-            if renpy.can_load(fn):
-                if not layout.yesno_prompt("save", u"Are you sure you want to overwrite your 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",  u"Loading will lose unsaved progress.\nAre you sure you want to do this?"):
-                    continue
-
-            renpy.load(fn)
-            
-            
-init python hide:
-    def auto_save_extra_info():
-        return save_name
-    config.auto_save_extra_info = auto_save_extra_info
-    

console.bat

@@ -0,0 +1,2 @@
+lib\windows-i686\python.exe -OO renpy.py
+pause

data/distribute.rpy

@@ -1,420 +0,0 @@
-# This file contains the code needed to build a Ren'Py distribution.
-
-init python:
-    import zipfile
-    import tarfile
-    import os
-    import os.path
-    import time
-    import sys
-    import zlib
-
-    # Returns true if a file or directory should not be included in
-    # the distribution
-
-    ignored_files = ("thumbs.db",
-                     "launcherinfo.py",
-                     "traceback.txt",
-                     "errors.txt",
-                     "completion.lua",)
-
-    def ignored(fn):
-        if fn[0] == ".":
-            return True
-
-        for i in store.ignore_extensions:
-            if fn.endswith(i):
-                return True
-
-        if fn.lower() in ignored_files:
-            return True
-
-        if fn == "saves":
-            return True
-
-        if fn == "archived":
-            return True
-
-        return False
-
-    def tree(src, dest,
-             exclude_suffix=[ ".pyc", "~", ".bak" ],
-             exclude_prefix=[ ".", '#' ],
-             exclude=ignored_files,
-             exclude_func=None,
-             ):
-
-        # Get rid of trailing slashes.
-        if src[-1] == "/":
-            src = src[:-1]
-
-        if dest and dest[-1] == "/":
-            dest = dest[:-1]
-
-        # What should we include?
-        def include(fn):
-            for i in exclude_suffix:
-                if fn.endswith(i):
-                    return False
-
-            for i in exclude_prefix:
-                if fn.startswith(i):
-                    return False
-
-            for i in exclude:
-                if i == fn.lower():
-                    return False
-
-            if exclude_func and exclude_func(fn):
-                return False
-
-            return True
-
-
-        rv = [ ]
-
-        # Walk the tree, including what is necessary.
-        for srcdir, dirs, files in os.walk(src):
-
-            if dest:
-                destdir = dest + srcdir[len(src):]
-            else:
-                destdir = srcdir[len(src) + 1:]
-
-            if destdir:
-                rv.append((srcdir, destdir))
-
-            for fn in files:
-
-                if not include(fn):
-                    continue
-
-                sfn = srcdir + "/" + fn
-
-                if destdir:
-                    dfn = destdir + "/" + fn
-                else:
-                    dfn = fn
-                    
-                rv.append((sfn, dfn))
-
-            dirs[:] = [ i for i in dirs if include(i) ]
-
-        return rv
-
-        
-label distribute:
-
-    python hide:
-        zlib.Z_DEFAULT_COMPRESSION = 9
-
-        store.progress_time = 0
-
-        def progress(tit, n, m, time=time):
-            
-            if time.time() < store.progress_time + .1:
-                return
-
-            title(tit)
-
-            mid(message)
-            ui.bar(m, n, xmaximum=200, xalign=0.5)
-            ui.close()
-
-            ui.pausebehavior(0)
-            interact()
-            
-        # Check to see which platforms we can build on.
-        if os.path.exists(config.renpy_base + "/renpy.exe"):
-            windows = True
-        else:
-            windows = False
-
-        if os.path.exists(config.renpy_base + "/lib/linux-x86"):
-            linux = True
-        else:
-            linux = False
-
-        if os.path.exists(config.renpy_base + "/renpy.app"):
-            mac = True
-        else:
-            mac = False
-
-        if not (windows or mac or linux):
-            store.error(u"Can't Distribute", u"Ren'Py is missing files required for distribution. Please download the full package from {a=http://www.renpy.org/}www.renpy.org{/a}.", "tools_menu")
-        
-        lint()
-
-        store.message = ""
-
-        title(_(u"Building Distributions"))
-
-        mid()
-        text(u"I've just performed a lint on your project. If it contains errors, you should say no and fix them.\nCheck {a=http://www.renpy.org/wiki/renpy/Download_Ren'Py}www.renpy.org{/a} to see if updates or fixes are available.\n\nDo you want to continue?")
-        ui.close()
-
-        bottom()
-        button(u"Yes", clicked=ui.returns(True))
-        button(u"No", clicked=ui.returns(False))
-        ui.close()
-
-        if not interact():
-            renpy.jump("tools")
-
-
-        # if not windows or not mac or not linux:
-        #    store.message = "The full version of Ren'Py can build for Windows, Mac, and Linux. Download it from www.renpy.org."
-            
-        title(u"Building Distributions")
-
-        mid()
-        text(u"Distributions will be built for the following platforms:")
-
-        spacer()
-
-        if windows:
-            text(u"Windows 98+", style='launcher_input')
-
-        if linux:
-            text(u"Linux x86", style='launcher_input')
-
-        if mac:
-            text(u"Mac OS X 10.4+", style='launcher_input')
-
-        spacer()
-
-
-        # TODO: If missing platforms, prompt for a DL.
-
-        text(u"Is this okay?")
-        ui.close()
-
-        bottom()
-        button(u"Yes", clicked=ui.returns(True))
-        button(u"No", clicked=ui.returns(False))
-        ui.close()
-
-        if not interact():
-            renpy.jump("tools")
-
-        default_name = project.name
-        if persistent.build_project == project.name:
-            default_name = persistent.build_name        
-
-        name = prompt(u"Building Distributions",
-                      u"Please enter a base name for the directories making up this distribution.",
-                      "tools",
-                      default_name,
-                      u"This usually should include a name and version number, like 'moonlight_walks-1.0'.")
-
-        name = name.strip()
-
-        if not name:
-            store.error(u"Error", u"The distribution name should not be empty.", "tools_menu")
-
-        try:
-            name = name.encode("ascii")
-        except:
-            store.error(u"Error", u"Distribution names must be ASCII. This is because archive file formats do not support non-ASCII characters in a uniform way.", "tools_menu")
-
-        persistent.build_project = project.name
-        persistent.build_name = name
-
-        ignore_extensions = persistent.ignore_extensions or "~ .bak"
-        ignore_extensions = prompt(u"Building Distributions", u"Please enter a space separated list of the file extensions you do not want included in the distribution.", "tools", ignore_extensions)
-        persistent.ignore_extensions = ignore_extensions    
-        store.ignore_extensions = [ i.strip() for i in ignore_extensions.strip().split() ]
-
-        
-        # Figure out the files that will make up the distribution.
-
-        multi = [ ]
-
-        # This finds the files and directories in the tree, and includes
-        # them in the result.
-
-                
-        # renpy and common directories.
-        multi.extend(tree(config.renpy_base + "/renpy", "renpy"))
-        multi.append((config.renpy_base + "/LICENSE.txt", "renpy/LICENSE.txt"))
-        multi.extend(tree(config.commondir, "common"))
-        
-        # Include the project.
-        multi.extend(tree(project.path, '',
-                          exclude_suffix = [ ],
-                          exclude_prefix = [ ],
-                          exclude=[ ],
-                          exclude_func = project.info["ignored"]))
-        
-        shortgamedir = project.gamedir[len(project.path)+1:]
-
-        for i in store.ignore_extensions:
-            if "script_version.rpy".endswith(i):
-                break
-        else:
-            multi.append((config.gamedir + "/script_version.rpy",
-                          shortgamedir + "/script_version.rpy"))
-
-        for i in store.ignore_extensions:
-            if "script_version.rpyc".endswith(i):
-                break
-        else:
-            multi.append((config.gamedir + "/script_version.rpyc",
-                          shortgamedir + "/script_version.rpyc"))
-       
-        # renpy.py
-        multi.append((config.renpy_base + "/renpy.py",
-                      project.name + ".py"))
-
-        # Windows Zip
-        if windows:
-            win_files = [
-                ( config.renpy_base + "/renpy.exe", project.name + ".exe"),
-                ( config.renpy_base + "/renpy.code", "renpy.code" ),
-                ( config.renpy_base + "/python25.dll", "python25.dll" ),
-                ( config.renpy_base + "/msvcr71.dll", "msvcr71.dll" ),
-                ]
-
-            zf = zipfile.ZipFile(name + ".zip", "w", zipfile.ZIP_DEFLATED)
-
-            progress_len = len(multi) + len(win_files)
-            store.message = u"Be sure to announce your project at the Lemma Soft Forums."
-                               
-            for i, (fn, an) in enumerate(multi + win_files):
-                progress(u"Building Windows", i, progress_len)
-
-                if os.path.isdir(fn):
-                    continue
-                
-                zi = zipfile.ZipInfo(name + "/" + an)
-
-                s = os.stat(fn)
-                zi.date_time = time.gmtime(s.st_mtime)[:6]
-                zi.compress_type = zipfile.ZIP_DEFLATED
-                zi.create_system = 3
-
-                zi.external_attr = long(0100666) << 16 
-                data = file(fn, "rb").read()
-
-                zf.writestr(zi, data)
-
-
-            zf.close()
-
-
-        # Linux Tar Bz2
-        if linux:
-
-            linux_files = [
-                (config.renpy_base + "/lib", "lib"),
-                (config.renpy_base + "/renpy.sh", project.name + ".sh"),
-                (config.renpy_base + "/lib/python", "lib/python"),
-                ]
-                
-
-            linux_files.extend(tree(config.renpy_base + "/lib/linux-x86", "lib/linux-x86"))
-
-
-            tf = tarfile.open(name + "-linux-x86.tar.bz2", "w:bz2")
-            tf.dereference = True
-
-            progress_len = len(multi) + len(linux_files)
-            store.message = u"If appropriate, please submit your game to www.renai.us."
-
-            for j, i in enumerate(multi + linux_files):
-
-                progress(u"Building Linux", j, progress_len)
-
-                fn, an = i
-
-                info = tf.gettarinfo(fn, name + "-linux-x86/" + an)
-
-                if info.isdir():
-                    perms = 0777
-                elif info.name.endswith(".sh"):
-                    perms = 0777
-                elif info.name.endswith(".so"):
-                    perms = 0777
-                elif info.name.endswith("python"):
-                    perms = 0777
-                elif info.name.endswith("python.real"):
-                    perms = 0777
-                else:
-                    perms = 0666
-
-                info.mode = perms
-                info.uid = 1000
-                info.gid = 1000
-                info.uname = "renpy"
-                info.gname = "renpy"
-
-                if info.isreg():
-                    tf.addfile(info, file(fn, "rb"))
-                else:
-                    tf.addfile(info)
-
-            tf.close()
-
-        if mac:
-
-            mac_files = tree(config.renpy_base + "/renpy.app",
-                             project.name + ".app")
-
-            zf = zipfile.ZipFile(name + "-mac.zip", "w", zipfile.ZIP_DEFLATED)
-
-            progress_len = len(multi) + len(mac_files)
-            store.message = u"Thank you for choosing Ren'Py."
-
-            for i, (fn, an) in enumerate(multi + mac_files):
-
-                progress(u"Building Mac OS X", i, progress_len)
-
-                if os.path.isdir(fn):
-                    continue
-
-                
-                zi = zipfile.ZipInfo(name + "-mac/" + an)
-                
-                s = os.stat(fn)
-                zi.date_time = time.gmtime(s.st_mtime)[:6]
-                zi.compress_type = zipfile.ZIP_DEFLATED
-                zi.create_system = 3
-
-                if os.path.dirname(fn).endswith("MacOS") or fn.endswith(".so") or fn.endswith(".dylib"):
-                    zi.external_attr = long(0100777) << 16 
-                    data = file(fn, "rb").read()
-                else:
-                    zi.external_attr = long(0100666) << 16 
-                    data = file(fn, "rb").read()
-
-                zf.writestr(zi, data)
-
-            zf.close()
-
-                
-        # Announce Success
-
-        store.message = ""
-
-        title(u"Success")
-
-        mid()
-        text(u"The distribution(s) have been built. Be sure to test them before release.")
-
-        spacer()
-
-        if mac:
-            text(u"Note that unpacking and repacking Mac zips and Linux tarballs on Windows isn't supported.")
-
-        ui.close()
-
-        bottom()
-        button(u"Return", clicked=ui.returns(True))
-        ui.close()
-        
-        interact()
-
-        
-    jump tools
-               
-        

data/editor.rpy

@@ -1,25 +0,0 @@
-# This file contains logic for detecting an editor, and for selecting
-# the default editor.
-
-init:
-    python hide:
-        import os
-        import sys
-
-        if not config.editor:
-
-            editor = config.renpy_base + "/jedit/jedit.jar"
-            editor = renpy.shell_escape(editor)
-
-            if sys.platform == 'win32':
-                config.editor = 'javaw.exe -jar "' + editor + '" -reuseview "%(filename)s" +line:%(line)d "%(otherfiles)s"'
-                config.editor_transient = 'javaw.exe -jar "' + editor + '" -newplainview "%(filename)s" +line:%(line)d "%(otherfiles)s"'
-            else:
-                config.editor = 'java -jar "' + editor + '" -reuseview "%(filename)s" +line:%(line)d "%(otherfiles)s"'
-                config.editor_transient = 'java -jar "' + editor + '" -newplainview "%(filename)s" +line:%(line)d "%(otherfiles)s"'
-            
-        if config.editor:
-            os.environ['RENPY_EDITOR'] = config.editor
-        if config.editor_transient:
-            os.environ['RENPY_EDITOR_TRANSIENT'] = config.editor_transient
-                

data/launcher.rpy

@@ -1,760 +0,0 @@
-python early:
-    config.save_directory = "launcher-1"
-
-init:
-
-    python:
-        # Set up the window.
-        config.screen_width = 350
-        config.screen_height = 450
-        config.window_title = "Ren'Py Launcher"
-                
-        # Disable sound and joystick.
-        config.sound = False
-        config.joystick = False
-        
-        # Disables autosave (we can't save/load)
-        config.has_autosave = False
-        
-        # Create some launcher styles.
-        style.create('launcher_button', 'button')
-        style.create('launcher_button_text', 'button_text')
-        style.create('launcher_title_label', 'default')
-        style.create('launcher_label', 'default')
-        style.create('launcher_input', 'default')
-        style.create('launcher_text', 'default')
-        style.create('launcher_bottom_vbox', 'vbox')
-        style.create('launcher_mid_vbox', 'vbox')
-
-        style_backup = renpy.style.backup()
-        
-        _launcher_per_page = 8
-        
-        # Choose the roundrect theme for the buttons.
-        layout.compat()
-        theme.roundrect(launcher=True)
-
-        style.hyperlink_text.color = "#0ff"
-
-        def quote(c):
-            n = ord(c)
-            if 0x20 <= n <= 0x7f:
-                return c
-            else:
-                return "\\x%02x" % n
-        
-        def ifrw(label):
-            if project.info.get("ro", False):
-                return None
-            else:
-                return ui.jumps(label)            
-
-        # We don't want the user going into the game menu.
-        def interact():
-            ui.window(background=Solid("#0008"), ypos=1.0, yminimum=80, xmargin=0, ymargin=0)
-            ui.null()
-
-            ui.image("eileen_small.png", xalign=0.0, yalign=1.0)
-            ui.add(DynamicDisplayable("Text(_(store.message), size=14, color='#fff', xpos=100, ypos=375, xmaximum=240)"))
-            ui.text(renpy.version(), xalign=0, yalign=1.0, size=12, color='#000')
-            
-            return ui.interact(suppress_underlay=True)
-
-        def title(name):
-            ui.window(style='mm_root')
-            ui.null()
-
-            ui.frame(xminimum=350, yminimum=370)
-            _label_factory(name, "launcher_title", size=28)
-            
-            # ui.text(name, xpos=4, ypos=4, size=30, color="#559")
-
-        def text(name, style="launcher_text"):
-            ui.text(_(name), style=style)
-            
-        def label(name):
-            _label_factory(name, "launcher")
-            
-        def spacer():
-            ui.add(Null(1, 6))
-
-        def mid(focus="mid"):
-            ui.vbox(style='launcher_mid_vbox', focus=focus)
-
-        def bottom(focus="bottom"):
-            ui.vbox(style='launcher_bottom_vbox', focus=focus)
-
-        def button(text, hover_text=None, clicked=None, hovered=None, selected=False):
-            if hover_text:
-                def hovered(hover_text=_(hover_text)):
-                    if store.message != hover_text:
-                        store.message = hover_text
-                        renpy.restart_interaction()
-                        
-            # ui.button(clicked=clicked, hovered=hovered)
-            # ui.text(text, style="button_text")
-            _button_factory(text, 'launcher', clicked=clicked, hovered=hovered, selected=selected)
-                
-
-        def prompt(name, message, cancel, default='', hint=''):
-            store.message = _(hint)
-
-            # Creating the project.
-            title(name)
-
-            mid()
-
-            text(message)
-
-            ui.input(default, exclude='{}/\\', style='launcher_input')
-
-            ui.close()
-
-            bottom()
-            button("Cancel", clicked=ui.jumps("main"))
-            ui.close()
-
-            return interact()
-
-        def error(name, message, target):
-            store.message = ''
-
-            # Creating the project.
-            title(name)
-
-            mid()
-            text(message)
-            ui.close()
-
-            bottom()
-            button("Cancel", clicked=ui.jumps(target))
-            ui.close()
-
-            return interact()
-
-
-        def paged_menu(tit, choices, message, per_page=None, cancel='main'):
-
-            if per_page is None:
-                per_page = _launcher_per_page
-            
-            page = 0
-            pages = (len(choices) - 1) / per_page
-
-
-            while True:
-
-                store.message = message
-
-                title(tit)
-
-                mid(focus="paged_menu")
-
-                for name, desc, ret, hovered, selected in choices[page * per_page:(page + 1) * per_page]:
-                    button(name, desc, clicked=ui.returns(("return", ret)), hovered=hovered, selected=selected)
-                    
-                ui.close()
-
-                bottom()
-
-                if pages >= 1:
-
-                    if page < pages:
-                        button(u"Next Page", u"Go to the next page of projects.", clicked=ui.returns(("page", page + 1)))
-                    else:
-                        button(u"Next Page")
-
-                    if page > 0:
-                        button(u"Previous Page", u"Go to the previous page of projects.", clicked=ui.returns(("page", page - 1)))
-                    else:
-                        button(u"Previous Page")
-
-                button(u"Cancel", u"Return to the top menu.", ui.jumps(cancel))
-                        
-                ui.close()
-
-                cmd, arg = interact()
-
-                if cmd == "repeat":
-                    continue
-                
-                if cmd == "page":
-                    page = arg
-                    continue
-
-                if cmd == "return":
-                    return arg
-
-        class ProcessBehavior(renpy.display.layout.Null):
-
-            def __init__(self, proc):
-                super(ProcessBehavior, self).__init__()
-
-                self.proc = proc
-
-            def event(self, ev, x, y, st):
-
-                if self.proc.poll() is not None:
-                    return True
-
-                renpy.game.interface.timeout(.25)
-
-        class Project(object):
-            def __init__(self, name, path, gamedir, info):
-                # name
-                self.name = name
-
-                # path to project
-                self.path = path
-
-                # gamedir
-                self.gamedir = gamedir
-
-                self.info = info
-
-                import re
-
-                def upper(m):
-                    return m.group(0).upper()
-
-                title = re.sub(r'^.', upper, name)
-                title = re.sub(r'\s+\S', upper, title)
-                self.title = title
-
-
-        def load_project(dir, name):
-            import os.path
-
-            # Ignore unicode files.
-            for i in name:
-                if ord(i) >= 127:
-                    return 
-
-            if os.path.isdir(dir + "/game"):
-                gamedir = dir + "/game"
-            elif os.path.isdir(dir + "/data"):
-                gamedir = dir + "/data"
-            else:
-                return
-
-            desc = u""
-
-            info = dict()
-            info["description"] = desc
-            info["ignored"] = ignored
-            
-            if os.path.exists(dir + "/launcherinfo.py"):
-                source = file(dir + "/launcherinfo.py", "rU").read().decode("utf8")
-                if source[0] == u'\ufeff':
-                    source = source[1:]
-                source = source.encode("raw_unicode_escape")
-
-                exec source in info
-
-            store.projects.append(Project(name, dir, gamedir, info))
-                
-        def load_projects():
-
-            import os
-            import os.path
-
-            store.projects = [ ]
-            
-            cwd = os.getcwd()
-
-            if cwd == config.renpy_base:
-                dirs = [ cwd ]
-            else:
-                dirs = [ config.renpy_base, cwd ]
-
-            for d in dirs:
-
-                contents = os.listdir(d)
-                contents.sort()
-
-                for dd in contents:
-                    dir = d + "/" + dd
-
-                    if os.path.isdir(dir):
-                        load_project(dir, dd)
-
-            if not store.projects:
-                raise Exception("The launcher will not function without any projects.")
-
-            
-        def lint():
-            
-            import renpy.subprocess as subprocess
-            import sys
-            import os.path
-
-            store.message = u"Lint in progress."
-            title(u"Lint")
-            ui.pausebehavior(0)
-            interact()
-
-            lf = file("lint.txt", "w+")
-            
-            if hasattr(sys, "winver") and sys.argv[0].lower().endswith(".exe"):
-                proc = subprocess.Popen([config.renpy_base + "/console.exe", "--lint", project.path], stdin=lf, stdout=lf, stderr=lf)
-            else:
-                proc = subprocess.Popen([sys.executable, sys.argv[0], "--lint", project.path], stdout=lf)
-
-            proc.wait()
-
-            lf.close()
-
-            renpy.launch_editor([ "lint.txt" ],transient=1)
-
-        def rmpersistent():
-            
-            import renpy.subprocess as subprocess
-            import sys
-            import os.path
-
-            store.message = u"Deleting persistent data."
-            title(u"Delete Persistent")
-            ui.pausebehavior(0)
-            interact()
-
-            if hasattr(sys, "winver") and sys.argv[0].lower().endswith(".exe"):
-                proc = subprocess.Popen([config.renpy_base + "/console.exe", "--rmpersistent", project.path])
-            else:
-                proc = subprocess.Popen([sys.executable, sys.argv[0], "--rmpersistent", project.path])
-
-            proc.wait()
-
-label main_menu:
-    return
-
-label find_project:
-
-    python hide:
-        load_projects()
-
-        wanted = persistent.project or "demo"
-
-        for p in projects:
-            if p.name == wanted:
-                store.project = p
-                break
-        else:
-            store.project = projects[0]
-
-
-        store.game_proc = None
-
-    return
-        
-    
-label start:
-
-    call find_project from _call_find_project_1
-    
-label main:
-
-    python:
-        store.message = u"What do you want to do?"
-
-label top_menu:
-    
-
-    python hide:
-
-        while True:
-
-            title(project.title)
-
-            mid()
-
-            label(u"This Project")
-
-            if not game_proc or game_proc.poll() is not None:
-                clicked = ui.jumps("launch")
-            else:
-                clicked = None
-
-            button(u"Launch",
-                   u"Starts the project running.",
-                   clicked=clicked)
-
-
-            if config.editor:
-                button(u"Edit Script",
-                       u"Edits the script files.",
-                       clicked=ui.jumps("edit"))
-
-
-            button(u"Change Theme",
-                   u"Changes the color theme of the project.",
-                   ifrw("choose_theme"))
-                
-            button(u"Game Directory",
-                   u"Opens the game directory.",
-                   clicked=ui.jumps("game_directory"))
-
-
-
-            button(u"Tools",
-                   u"Shows the tools menu.",
-                   clicked=ui.jumps("tools"))
-
-            spacer()
-
-            label(u"Change Project")
-
-            button(u"Select Project",
-                   u"Select a project to work with.",
-                   clicked=ui.jumps("select_project"))
-
-            button(u"New Project",
-                   u"Create a new project from a template.",
-                   clicked=ui.jumps("new"))
-
-            ui.close()
-
-            bottom()
-            button(u"Documentation", u"Read Ren'Py tutorials and manuals.", clicked=ui.jumps("documentation"))
-            button(u"Quit", u"Quit the Ren'Py Launcher.", clicked=ui.jumps("confirm_quit"))
-            ui.close()
-
-
-            if game_proc and game_proc.poll() is None:
-                ui.add(ProcessBehavior(game_proc))
-
-            interact()
-
-    jump top_menu
-
-label select_project:
-
-    python hide:
-
-        choices = [ (p.name, p.info["description"], p, None, False) for p in projects if not p.info.get("template") ]
-
-        store.project = paged_menu(u"Select a Project", choices, u"Please select a project.")
-
-        persistent.project = store.project.name
-
-        store.game_proc = None
-
-    jump main
-
-label launch:
-
-    python hide:
-        import renpy.subprocess
-        import sys
-        import os.path
-        import os
-        
-        if hasattr(sys, "winver") and sys.argv[0].lower().endswith(".exe"):
-            proc = renpy.subprocess.Popen([sys.argv[0], project.path])
-        else:
-            proc = renpy.subprocess.Popen([sys.executable, sys.argv[0], project.path])
-
-        store.message = _(u"%s has been launched.") % project.title 
-
-        store.game_proc = proc
-        
-
-    jump top_menu
-
-            
-            
-label edit:
-
-    python hide:
-        import os
-
-        
-        files = [ project.gamedir + "/" + i for i in os.listdir(project.gamedir) if i.endswith(".rpy") if not i[0] == "."]
-
-        files.sort()
-
-        for i in files[:]:
-            if i.endswith("options.rpy"):
-                files.remove(i)
-                files.insert(0, i)
-
-        for i in files[:]:
-            if i.endswith("script.rpy"):
-                files.remove(i)
-                files.insert(0, i)
-            
-        renpy.launch_editor(files)
-        
-        store.message = _(u"Launched editor with %d script files.") % len(files)
-
-    jump top_menu
-
-label game_directory:
-
-    python hide:
-        import os
-        import os.path
-        import platform
-        import sys
-        
-        gamedir = os.path.normpath(project.gamedir)
-
-        if sys.platform == "win32":
-            os.startfile(gamedir)
-        elif platform.mac_ver()[0]:
-            import renpy.subprocess as subprocess
-            subprocess.Popen([ "open", gamedir ])
-        else:
-            store.message = _(u"Opening the game directory is not supported on this platform.\n%s") % gamedir
-
-        gamedir = "".join(quote(i) for i in gamedir)
-        
-        store.message = _(u"Opening game directory:\n%s") % gamedir
-            
-    jump top_menu
-                     
-
-label tools:
-
-    $ store.message = u"Please choose a tool you want to use with this project."
-
-label tools_menu:
-
-    python hide:
-
-        title(_("Tools: %s") % project.title)
-
-        mid()
-
-        label(u"Anytime")
-
-        button(u"Check Script (Lint)",
-               u"Checks the game's script for likely errors. This should be run before releasing.",
-               clicked=ui.jumps("lint"))
-
-
-        button(u"Delete Persistent",
-               u"Deletes the game's persistent data.",
-               clicked=ui.jumps("rmpersistent"))
-        
-        # button("Quick Backup",
-        #       "Makes a backup copy of the project. You also need to make backups somewhere other then this computer.",
-        #       clicked=ui.jumps("backup"))
-
-        spacer()
-
-        label(u"Release Day")
-
-        button(u"Add From to Calls",
-               u"Adds a from clause to each of the call statements in your script.", 
-               clicked=ifrw("add_from_to_calls"))
-        
-        button(u"Archive Files",
-               u"Archive files found under the game and archived directories.",
-               clicked=ifrw("archive_files"))
-               
-        button(u"Build Distributions",
-               u"Build distributions for the platforms supported by Ren'Py.",
-               clicked=ui.jumps("distribute"))
-
-        ui.close()
-
-        bottom()
-
-        button(u"Back",
-               u"Goes back to the top menu.",
-               clicked=ui.jumps("main"))
-
-        ui.close()
-
-        interact()
-        
-label lint:
-
-    python hide:
-        lint()
-
-        store.message = u"A lint report should appear shortly."
-
-    jump tools_menu
-        
-
-
-label archive_files:
-
-    python hide:
-        import os
-        import os.path
-
-        import renpy.tools.archiver as archiver
-
-        extensions = persistent.archive_extensions or "*.png *.gif *.jpg"
-        extensions = prompt(u"Archiving Files", u"Please enter a space separated list of the file patterns you want archived.", "tools", extensions)
-        if not extensions.strip():
-            renpy.jumps("tools_menu")
-        persistent.archive_extensions = extensions    
-        extensions = [ i.strip() for i in extensions.strip().split() ]
-
-
-        base = persistent.archive_base or "data"
-        base = prompt(u"Archiving Files", u"Please enter the name of the archive file, without the .rpa extension.", "tools", base)
-        base = base.strip()
-        if not base:
-            renpy.jumps("tools_menu")
-        persistent.archive_base = base 
-
-        # Tell the user we're archiving images.
-        title(u"Archiving Files")
-        store.message = u"Please wait while we archive files."
-        ui.pausebehavior(0)
-        interact()
-
-
-        gamedir = project.gamedir
-        archived = project.path + "/archived"
-
-        files = [ ]
-        prefix = gamedir + "/" + base
-
-        def should_archive(fn, extensions=extensions):
-            import fnmatch
-            
-            fn = fn.lower()
-
-            if fn[0] == ".":
-                return False
-
-            if fn == "presplash.png":
-                return False
-            
-            for e in extensions:
-                if fnmatch.fnmatch(fn, e):
-                    return True
-
-            return False
-
-        archived_files = set()
-        
-        for bdir in (gamedir, archived):
-
-            for dirname, dirs, filenames in os.walk(bdir):
-
-                # Ignore svn.
-                dirs[:] = [ i for i in dirs if not i[0] == '.' ]
-
-                for fn in filenames:
-                    
-                    fullfn = dirname + "/" + fn
-                    shortfn = fullfn[len(bdir)+1:]
-
-                    if shortfn in archived_files:
-                        continue
-                    
-                    if not should_archive(shortfn):
-                        continue
-
-                    files.append((fullfn, shortfn))
-                    archived_files.add(shortfn)
-                    
-        archiver.archive(prefix, files)
-
-#         f = file(gamedir + "/images.rpy", "w")
-#         print >>f, "init:"
-#         print >>f, "    $ config.archives.append('images')"
-#         f.close()
-                    
-        for fullfn, shortfn in files:
-            afn = archived + "/" + shortfn
-
-            if fullfn == afn:
-                continue
-
-            try:
-                os.makedirs(os.path.dirname(afn))
-            except:
-                pass
-
-            try:
-                os.rename(fullfn, afn)
-            except:
-                os.rename(afn, afn + ".old")
-                os.rename(fullfn, afn)
-                os.unlink(afn + ".old")
-                
-        store.message = u"The files have been added to the archive, and moved into the archived directory."
-
-    jump tools_menu
-
-label backup:
-
-    python hide:
-        import os
-        import time
-        import shutil
-
-        # Tell the user we're archiving images.
-        title(u"Making Backup")
-        store.message = u"Please wait while we make a backup."
-        ui.pausebehavior(0)
-        interact()
-
-        try:
-            os.mkdir('backups')
-        except:
-            pass
-
-        while True:
-
-            btime = str(int(time.time()))
-            bdir = "backups/%s.%s" % (project.name, btime)
-
-            if not os.path.exists(bdir):
-                break
-
-            time.sleep(1)
-
-        shutil.copytree(project.path, bdir)
-
-        store.message = _(u"The backup was placed into %s.") % bdir
-
-    jump tools_menu
-                
-
-label add_from_to_calls:
-
-    python hide:
-        import os
-        import time
-        import shutil
-
-        title(u"Add From to Calls")
-        store.message = u"Please wait while we add from clauses to call statements."
-        ui.pausebehavior(0)
-        interact()
-
-        import renpy.tools.add_from as add_from
-
-        add_from.add_from(project.gamedir, config.commondir)
-
-        store.message = _(u"Done adding from clauses to call statements. You may want to remove the .bak files created.")
-
-    jump tools_menu
-
-label rmpersistent:
-
-    python hide:
-        rmpersistent()
-        store.message = _(u"Done deleting persistent data.")
-
-    jump tools_menu
-                
-        
-label confirm_quit:
-    $ renpy.quit()
-    
-label documentation:
-    python hide:
-        import webbrowser
-        webbrowser.open_new("file:///" + config.renpy_base + "/doc/index.html")
-        store.message = _(u"Now showing the Ren'Py documentation in your web browser.")
-
-    jump top_menu

data/new.rpy

@@ -1,167 +0,0 @@
-label new:
-
-    python hide:
-
-        import os
-        import os.path
-        import time
-        
-
-        # Select a template.
-        
-        choices = [ (p.name, p.info["description"], p, None, False) for p in projects if p.info.get("template", None)]
-
-        template = paged_menu(u"Select a Template", choices, u"Please select a project to use as a template for your project.")
-
-        # Choose project name.
-        
-        name = prompt(u"Project Name", u"Type the name of your new project, and press enter.\n", "main")
-        name = name.strip()
-
-        error = None
-
-        if not name:
-            error = u"Please enter a non-empty project name."
-        elif os.path.exists(name):
-            error = u"A file or directory named '%s' already exists." % name
-        else:
-            try:
-                name = name.encode("ascii")
-            except:
-                error = u"Project names must be ASCII. This is because the ZIP file format does not support non-ASCII characters in a uniform way."
-                
-        if error:
-            store.error(u"Error", error, "main")
-
-        # Tell the user we're creating the project.
-        title(u"Creating Project")
-        store.message = u"Please wait while we create the project."
-        ui.pausebehavior(0)
-        interact()
-                    
-        # Here is where we actually create the project.
-
-        import shutil
-
-        shutil.copytree(template.path, name)
-
-        unlink = template.info.get("unlink", [ ])
-        unlink += [ 'launcherinfo.py' ]
-        
-        for i in unlink:
-            if os.path.exists(name + "/" + i):
-                os.unlink(name + "/" + i)
-
-        for dir, dirs, files in os.walk(name):
-            for d in list(dirs):
-                if d.startswith("."):
-                    dirs.remove(d)
-                    dn = dir + "/" + d
-                    shutil.rmtree(dn)
-                
-        # Change the save directory.
-        options = file(name + "/game/options.rpy").read()
-        save_dir = "%s-%d" % (name, time.time())
-        options = options.replace("template-1220804310", save_dir)
-        file(name + "/game/options.rpy", "w").write(options)
-                
-        persistent.project = name
-
-    call find_project from _call_find_project_2
-
-label choose_theme:
-
-    python hide:
-        
-        # Select a color scheme.
-        
-        themes = theme_data.keys()
-        themes.sort()
-        
-        choices = [ ]
-        for i in themes:
-
-            def hovered(i=i):
-                td = theme_data[i].copy()
-                engine = td["theme"]
-                del td["theme"]
-
-                if engine == "roundrect":
-                    renpy.style.restore(style_backup)
-                    theme.roundrect(launcher=True, **td)
-                    renpy.style.rebuild()
-                    return ("repeat", 0)
-
-            choices.append((i, None, i, hovered, False))
-
-        color_theme = paged_menu(u"Select a Theme", choices, u"Please select a color theme for your project. You can always change the colors later.", cancel='color_theme_cancel')
-
-        # Restore default theme.
-        renpy.style.restore(style_backup)
-        theme.roundrect(launcher=True)
-        renpy.style.rebuild()
-
-        ofn = project.path + "/game/options.rpy"
-
-        import os
-        import re
-
-        if not os.path.exists(ofn):
-            error(u"Changing Theme", u"The options file does not seem to exist.", "main")
-        
-        inf = file(ofn, "rU")
-        outf = file(ofn + ".new", "w")
-
-        td = theme_data[color_theme]
-
-        # TODO: Make this less specific to roundrect. Need to figure out
-        # how to switch themes, rather than just recolor them.
-
-        changing = False
-        changed = False
-        
-        for l in inf:
-
-            if re.match(r'\s*theme.roundrect\(', l):
-                changing = True
-                changed = True
-            elif re.match(r'\s*\)', l):
-                changing = False
-            elif changing:
-
-                def repl(m, td=td):
-                    return m.group(1) + m.group(2) + " = \"" + td.get(m.group(2), m.group(3)) + "\","
-
-                l = re.sub(r'^(\s*)(\w+) = "([\da-fA-F#]+)",', repl, l)
-                
-            outf.write(l)
-
-        outf.close()
-        inf.close()
-
-        try:
-            os.rename(ofn + ".new", ofn)            
-        except:
-            
-            # I hate windows.
-            os.rename(ofn, ofn + ".old")
-            os.rename(ofn + ".new", ofn)
-            os.unlink(ofn + ".old")
-            
-        if not changed:
-            error(u"Changing Theme", u"Could not modify options.rpy, perhaps it was edited too much.", "main")
-        
-    jump main
-        
-
-
-label color_theme_cancel:
-
-    python hide:
-
-        # Restore default theme.
-        renpy.style.restore(style_backup)
-        theme.roundrect(launcher=True)
-        renpy.style.rebuild()
-
-    jump main

data/script_version.rpy

@@ -1,3 +0,0 @@
-init -50:
-    $ config.script_version = (6, 7, 1)
-    

data/themes_data.rpy

@@ -1,244 +0,0 @@
-init 1 python:
-    theme_data = {'Basic Blue': {'disabled': '#404040',
-                'disabled_text': '#c8c8c8',
-                'frame': '#6496c8',
-                'gm_root': '#dcebff',
-                'label': '#ffffff',
-                'mm_root': '#dcebff',
-                'theme': 'roundrect',
-                'widget': '#003c78',
-                'widget_hover': '#0050a0',
-                'widget_selected': '#ffffc8',
-                'widget_text': '#c8ffff'},
- 'Bloody Mary': {'disabled': '#400000',
-                 'disabled_text': '#260000',
-                 'frame': '#400808',
-                 'gm_root': '#000000',
-                 'label': '#ffffff',
-                 'mm_root': '#000000',
-                 'theme': 'roundrect',
-                 'widget': '#000000',
-                 'widget_hover': '#830000',
-                 'widget_selected': '#ffffff',
-                 'widget_text': '#C2C2C2'},
- 'Colorblind': {'disabled': '#898989',
-                'disabled_text': '#666666',
-                'frame': '#252525',
-                'gm_root': '#393939',
-                'label': '#c2c2c2',
-                'mm_root': '#393939',
-                'theme': 'roundrect',
-                'widget': '#898989',
-                'widget_hover': '#464646',
-                'widget_selected': '#F2F2F2',
-                'widget_text': '#CCCCCC'},
- 'Cotton Candy': {'disabled': '#C8AFA1',
-                  'disabled_text': '#E1D4C9',
-                  'frame': '#FCF5F2',
-                  'gm_root': '#D0B4BA',
-                  'label': '#805C40',
-                  'mm_root': '#D0B4BA',
-                  'theme': 'roundrect',
-                  'widget': '#ECC7D0',
-                  'widget_hover': '#E1D4C9',
-                  'widget_selected': '#805C40',
-                  'widget_text': '#805C40'},
- 'Creamsicle': {'disabled': '#FFECBF',
-                'disabled_text': '#ffffff',
-                'frame': '#FFECBF',
-                'gm_root': '#FDF5E3',
-                'label': '#502F13',
-                'mm_root': '#FDF5E3',
-                'theme': 'roundrect',
-                'widget': '#D96B00',
-                'widget_hover': '#FD9B1C',
-                'widget_selected': '#ffffff',
-                'widget_text': '#FCE6B1'},
- 'Dramatic Flesh': {'disabled': '#ab6038',
-                    'disabled_text': '#BF7C51',
-                    'frame': '#49271b',
-                    'gm_root': '#2a201f',
-                    'label': '#ffffff',
-                    'mm_root': '#2a201f',
-                    'theme': 'roundrect',
-                    'widget': '#BF7C51',
-                    'widget_hover': '#dda570',
-                    'widget_selected': '#ffffff',
-                    'widget_text': '#E5DFDF'},
- 'Easter Baby': {'disabled': '#DDE9FF',
-                 'disabled_text': '#A6AFBF',
-                 'frame': '#CCF8DC',
-                 'gm_root': '#FBF9DF',
-                 'label': '#698071',
-                 'mm_root': '#FBF9DF',
-                 'theme': 'roundrect',
-                 'widget': '#F5D4EE',
-                 'widget_hover': '#F0DDFF',
-                 'widget_selected': '#000000',
-                 'widget_text': '#698071'},
- 'Favorite Jeans': {'disabled': '#919994',
-                    'disabled_text': '#B6BFB9',
-                    'frame': '#6f7571',
-                    'gm_root': '#b0b8ba',
-                    'label': '#ffffff',
-                    'mm_root': '#b0b8ba',
-                    'theme': 'roundrect',
-                    'widget': '#8699a7',
-                    'widget_hover': '#9eb1ad',
-                    'widget_selected': '#ffffff',
-                    'widget_text': '#dcdfd6'},
- 'Fine China': {'disabled': '#ADB9CC',
-                'disabled_text': '#DFBA14',
-                'frame': '#ADB9CC',
-                'gm_root': '#F7F7FA',
-                'label': '#39435E',
-                'mm_root': '#F7F7FA',
-                'theme': 'roundrect',
-                'widget': '#6A7183',
-                'widget_hover': '#1A2B47',
-                'widget_selected': '#E3E3E4',
-                'widget_text': '#C9C9CB'},
- 'First Valentines': {'disabled': '#F8F2D0',
-                      'disabled_text': '#BFA1A1',
-                      'frame': '#F8F2D0',
-                      'gm_root': '#D98989',
-                      'label': '#5D1010',
-                      'mm_root': '#D98989',
-                      'theme': 'roundrect',
-                      'widget': '#F09898',
-                      'widget_hover': '#D6C5BB',
-                      'widget_selected': '#B31E1E',
-                      'widget_text': '#593131'},
- 'Ice Queen': {'disabled': '#F0F2F2',
-               'disabled_text': '#FBFBFB',
-               'frame': '#ffffff',
-               'gm_root': '#E6E6E6',
-               'label': '#D9D9D9',
-               'mm_root': '#E6E6E6',
-               'theme': 'roundrect',
-               'widget': '#D9D9D9',
-               'widget_hover': '#F0F2F2',
-               'widget_selected': '#737373',
-               'widget_text': '#ffffff'},
- 'Mocha Latte': {'disabled': '#614D3A',
-                 'disabled_text': '#80654D',
-                 'frame': '#926841',
-                 'gm_root': '#1A140E',
-                 'label': '#F1EBE5',
-                 'mm_root': '#1A140E',
-                 'theme': 'roundrect',
-                 'widget': '#4D3B29',
-                 'widget_hover': '#996E45',
-                 'widget_selected': '#ffffff',
-                 'widget_text': '#B99D83'},
- 'Muted Horror': {'disabled': '#73735C',
-                  'disabled_text': '#8C8C70',
-                  'frame': '#555544',
-                  'gm_root': '#1A0001',
-                  'label': '#1A0001',
-                  'mm_root': '#1A0001',
-                  'theme': 'roundrect',
-                  'widget': '#777777',
-                  'widget_hover': '#73735C',
-                  'widget_selected': '#000000',
-                  'widget_text': '#404033'},
- 'Old Polaroid': {'disabled': '#A89E7D',
-                  'disabled_text': '#CCC097',
-                  'frame': '#49403E',
-                  'gm_root': '#A84A3E',
-                  'label': '#ffffff',
-                  'mm_root': '#A84A3E',
-                  'theme': 'roundrect',
-                  'widget': '#A89E7D',
-                  'widget_hover': '#8DB6B9',
-                  'widget_selected': '#ffffff',
-                  'widget_text': '#49403E'},
- 'Really Red': {'disabled': '#404040',
-                'disabled_text': '#c8c8c8',
-                'frame': '#e17373',
-                'gm_root': '#ffd0d0',
-                'label': '#ffffff',
-                'mm_root': '#ffd0d0',
-                'theme': 'roundrect',
-                'widget': '#963232',
-                'widget_hover': '#c83232',
-                'widget_selected': '#ffffc8',
-                'widget_text': '#ffffff'},
- 'Summer Sky': {'disabled': '#6074BF',
-                'disabled_text': '#7383BF',
-                'frame': '#6074BF',
-                'gm_root': '#B4CDD4',
-                'label': '#94C7D4',
-                'mm_root': '#B4CDD4',
-                'theme': 'roundrect',
-                'widget': '#F2E6AA',
-                'widget_hover': '#FCFCA4',
-                'widget_selected': '#1A5766',
-                'widget_text': '#7DA8B3'},
- 'Swamp Critter': {'disabled': '#A2521D',
-                   'disabled_text': '#753D00',
-                   'frame': '#797C1C',
-                   'gm_root': '#B09D5A',
-                   'label': '#ffffff',
-                   'mm_root': '#B09B4F',
-                   'theme': 'roundrect',
-                   'widget': '#753D00',
-                   'widget_hover': '#B19A48',
-                   'widget_selected': '#ffffff',
-                   'widget_text': '#CCCAC2'},
- 'Urban Sprawl': {'disabled': '#8F0000',
-                  'disabled_text': '#333333',
-                  'frame': '#8F0000',
-                  'gm_root': '#000000',
-                  'label': '#ffffff',
-                  'mm_root': '#000000',
-                  'theme': 'roundrect',
-                  'widget': '#333333',
-                  'widget_hover': '#000000',
-                  'widget_selected': '#ffffff',
-                  'widget_text': '#6C8A2F'},
- 'Victorian Gingerbread': {'disabled': '#7A674F',
-                           'disabled_text': '#664F33',
-                           'frame': '#BF8A73',
-                           'gm_root': '#695640',
-                           'label': '#F2EDC4',
-                           'mm_root': '#695640',
-                           'theme': 'roundrect',
-                           'widget': '#7A674F',
-                           'widget_hover': '#BDA77D',
-                           'widget_selected': '#FDFBEE',
-                           'widget_text': '#F2EDC4'},
- 'Watermelon Pie': {'disabled': '#FABF46',
-                    'disabled_text': '#FFE06D',
-                    'frame': '#C3CD91',
-                    'gm_root': '#F7F7C5',
-                    'label': '#FCFCD7',
-                    'mm_root': '#F7F7C5',
-                    'theme': 'roundrect',
-                    'widget': '#FFE06D',
-                    'widget_hover': '#E38A4F',
-                    'widget_selected': '#996600',
-                    'widget_text': '#FAA700'},
- 'White Chocolate': {'disabled': '#614D3A',
-                     'disabled_text': '#80654D',
-                     'frame': '#926841',
-                     'gm_root': '#FBF9EA',
-                     'label': '#F1EBE5',
-                     'mm_root': '#FBF9EA',
-                     'theme': 'roundrect',
-                     'widget': '#33271C',
-                     'widget_hover': '#ECE7C4',
-                     'widget_selected': '#ffffff',
-                     'widget_text': '#B99D83'},
- 'Winter Mint': {'disabled': '#426143',
-                 'disabled_text': '#819981',
-                 'frame': '#245536',
-                 'gm_root': '#e5f1e5',
-                 'label': '#ffffff',
-                 'mm_root': '#e5f1e5',
-                 'theme': 'roundrect',
-                 'widget': '#7AA27B',
-                 'widget_hover': '#A3C7A3',
-                 'widget_selected': '#ffffff',
-                 'widget_text': '#CDE0CE'}}
-