6.12.0d

Better logging on image cache misses.

Minor bug/doc fixes.

.bzrignore

@@ -5,11 +5,96 @@ renpy.app
 **/*.rpyc
 **/*.rpyb
 **/*.rpymc
-_renpy.c
-nativemidi.c
-sound.c
-winmixer.c
 jedit
 lint.txt
 renpy.code
 traceback.txt
+doc/common.css
+doc/images
+doc/index.html
+doc/monobook.css
+doc/monobook2.css
+doc/reference
+doc/shared.css
+doc/tutorials
+doc/www.renpy.org
+testing
+translations.rpy
+launchertrans.rpy
+jcc
+scite/scite.zip
+screenshot*
+.ropeproject
+release_cardgame.sh
+cardgame
+dse.split
+empty
+empty-linux-x86.tar.bz2
+empty-mac.zip
+empty.zip
+errors.txt
+icons
+iliad-icon.png
+iliad-work
+kuroi
+lsprofcalltree.py
+manifest.xml
+mediatest
+musicroom
+nobmtest
+renpy-iliad.sh
+renpy.kcg
+renpy.stats
+renpygame-1.2.zip
+speedtest
+styles.txt
+renpygame-demo/game/saves
+Lucy Sprites.zip
+translate
+close_bugs.py
+.logplayer
+scite-6.10.zip
+scite-renpy-20090803.zip
+module/cython.sh
+old_demo
+opengl.txt
+Microsoft.VC90.CRT.manifest
+console.exe
+msvcr90.dll
+python26.dll
+renpy.exe
+lib/windows-x86
+sphinx/source/inc/*
+doc/*
+updates/prerelease
+module/render.c
+module/_renpy.c
+module/_renpy_pysdlgl.c
+module/_renpybidi.c
+module/sound.c
+module/winmixer.c
+module/accelerator.html
+module/gldraw.html
+module/glenviron_fixed.html
+module/glenviron.html
+module/glenviron_limited.html
+module/glenviron_shader.html
+module/glrtt_copy.html
+module/glshader.html
+module/gltexture.html
+module/render.html
+module/accelerator.c
+module/gldraw.c
+module/glenviron.c
+module/glenviron_fixed.c
+module/glenviron_limited.c
+module/glenviron_shader.c
+module/glrtt_copy.c
+module/glshader.c
+module/gltexture.c
+log.txt
+lib/linux-x86
+lib/python
+lib/update-version.txt
+sphinx/game/saves
+tutorial/game/saves

CHANGELOG.txt

@@ -1,3 +1,709 @@
+
+New in Ren'Py 6.10.2
+--------------------
+
+Ren'Py now caches the individual words of text that are rendered. This
+can lead to a speedup in text display when there are many words of
+text on the screen, and that text is re-displayed, as is the case
+where the text text speed is not the maximum. This is especially 
+beneficial for eastasian languages, where every character is treated
+as a word.
+
+
+The new config.menu_clear_layers variable allows layers to be cleared 
+when entering the game menu. This makes it easier for a layer to have 
+overlay-like things on it when in the game, but not when in the game
+menu.
+
+
+The new renpy.cache_pin function pins images into memory, loading them
+as soon as possible and keeping them loaded. The renpy.cache_unpin function
+undoes this.
+
+
+The new config.automatic_images_strip variable can strip out prefixes
+when automatically defining images.
+
+
+It's now possible to assign style properties to individual imagemap
+buttons, by indexing style.imagemap_button. (So for example, one could 
+assign to style.imagemap_button["Start Game"].hover_sound .)
+
+
+The new voice_replay function replays the voice played on the current
+interaction. The new voice_can_replay function returns True if a voice
+can be replayed.
+
+
+The launcher now accepts a RENPY_DEFAULT_PROJECTS_DIRECTORY, which sets
+the default for the projects directory, if it has not already been set 
+by the user. It also will report an error when creating a project fails,
+rather than producing a traceback.
+
+
+The launcher now links to the new Ren'Py Games List, at
+http://games.renpy.org/.
+
+
+Previously, it was impossible to pass an arguments list to a call
+expression. Now, we allow the pass keyword to be used to distinguish 
+the two, using code like:
+
+call expression foo pass (bar, baz)
+
+
+Ren'Py will now not show the click-to-continue indicator when a
+character is called with interact=False, unless that character is also
+called with ctc_force=True.
+
+
+Ren'Py now builds zip files in distributions 64k at a time. 
+
+
+Ren'Py will now ignore music files that do not exist. Previously, it
+could loop trying to play them. (This would increase CPU usage, rather
+than causing a crash.)
+
+
+The following numbered bugs were fixed:
+
+* lp:501351 - Displaying a Frame() with tile=True crashes
+* lp:506322 - MoveTransition is not applied to overlay even when explicitly stated
+
+In addition:
+
+* Fixed a bug that caused pixellate to crash.
+* Fixed a bug that caused the overlay to display twice in some cases.
+* Fix an infinite loop that could rarely occur when rolling back or saving.
+
+
+
+New in Ren'Py 6.10.1
+--------------------
+
+Images and other surfaces are now created with a 1px transparent border
+around them. This change allows transform to work correctly with a 1:1
+scale, where as previously Ren'Py would blur the image slightly, while
+trying to ensure it never accessed a pixel outside of the original 
+image bounds.
+
+
+ATL now has a "function" statement, which allows an ATL transform to
+use the same functions that are supplied to Transform.
+
+
+The layout.imagemap_main_menu and layout.imagemap_load_save functions 
+now allow one to define variant screens. This allows one to select an 
+imagemap main menu screen to use, or to define different screens for
+loading and saving.
+
+
+The overlay semantics were changed such that transitions apply to overlays
+in the same way they apply to everything else. (So, for example, dissolves
+will apply to overlays.)
+
+
+The image text tag can now take any textual image representation. So 
+something like {image=eileen happy} is legal, if odd.
+
+
+The following numbered bugs were fixed:
+
+lp:366412 - Ren'Py could crash on shift+R at the main menu, under some circumstances.
+
+lp:485631 - The transfer of state from a transfrom to a transform  supplied as part of an image didn't work.
+
+lp:487688 - non-ASCII characters didn't display in the window title bar.
+
+lp:487701 - Ren'Py didn't work when in a directory containing non-ASCII characters.
+
+lp:488814 - Scaling to the same size could blur an image.
+
+lp:489212 - Interpolation didn't work when the starting value was None.
+
+lp:493062 - One could roll back into an imagemap main menu.
+
+lp:494779 - The window shown state wasn't being tracked correctly.
+
+lp:494820 - Error handling in ATL hid too many error messages.
+
+A major bug that caused Ren'Py to fail as scaling was enabled was fixed.
+
+A number of minor bugs revealed by pyflakes were fixed.
+
+
+
+New in Ren'Py 6.10.0
+--------------------
+
+The demo game is in the process of being converted into a new tutorial
+game, which shows recommended Ren'Py code examples rather than
+requiring the user to learn from the game itself's source code.
+
+
+Ren'Py now supports an Animation and Transformation language
+(ATL). This provides a convenient syntax for animating an image, or
+transforming it by positioning it, rotating it, zooming it, and
+adjusting its opacity.
+
+To a large extent, ATL supersedes the Animation, TransitionAnimation,
+anim.SMAnimation, anim.Blink, Zoom, FactorZoom, RotoZoom, SizeZoom,
+LiveCrop, Move, Pan, Position, Motion, and Revolve functions, and
+perhaps others. As it allows properties to be scripted, ATL is more
+powerful that all of these functions. (For example, many of these
+functions can only do relatively simple repeats, while ATL allows
+complex patterns to be easily specified.)
+
+ATL can be used in the new transform statement, and new variants of
+the image, scene, and show statements.
+
+
+When an image is shown, Ren'Py checks to see if there was a previous
+image with that tag, and if that image used a transform. If this is
+true, Ren'Py does two things:
+
+# If the new image is not a transform, it wraps it in a transform.
+# The transform is initialized to have the properties of the old transform.
+
+The generally has the effect of "remembering" the position of images
+shown on the screen. In some cases, this memory effect may override a
+position encoded into an image. In that case, the image must be hidden
+and shown again.
+
+
+The default positions (left, right, center, truecenter, offscreenleft,
+and offscreenright) are now defined as ATL transforms. This means that showing
+an image at such a position will cause the position to be remembered.
+
+
+Support for Arabic and Hebrew has been added to Ren'Py. To enable this
+support, config.rtl needs to be set to True. It may also be necessary
+to set various style properties to do a credible job of right-to-left 
+layout.)
+
+
+The freetype library has been updated, and we have added support for
+the use of TrueType collections. Using a name of 0@font.ttc will get
+the first font in the collection, 1@font.ttc will get the second font,
+and so on.
+
+
+The displayable code has been adjusted to consider strings that do not
+contain at least one dot as image references. Now, one can write
+"eileen happy" to refer to an image with that name.
+
+
+A pause statement has been added to Ren'Py. 
+
+
+The new config.auto_load variable allows you to specify a save file
+that is automatically loaded when Ren'Py starts. For example, setting
+this to "1" loads the game in save slot 1. This is intended for use by
+developers, so they can easily return to a point in the game after 
+restarting Ren'Py.
+
+
+The layout.imagemap_yesno_prompt now supports a prompt_images
+argument, which is can be used to specify images to replace the
+text of a yes/no prompt.
+
+
+The new ui.tag function allows one to specify the image tag of a UI
+widget. This can have positive interactions with transforms.
+
+
+Ren'Py now has a define statement, which combines into a single
+statement running code at init time, and assigning it to a
+variable. Ren'Py keeps track of these definitions, which may in the 
+future make it easier for editors to determine where something is
+defined.
+
+
+The new config.window_overlay_functions variable contains a list of
+functions that should be called only when once the dialogue window has
+been shown.
+
+
+The new config.automatic_images variable, when set correctly, will
+cause Ren'Py to automatically define images for appropriately-named
+image files found in the archives and game directory.
+
+
+Python blocks are now compiled in a mode that allows the python "with"
+statement. Container displayables now support the context manager
+protocol, automatically closing at the end of a with block. (Note
+that the python with statement postdates the Ren'Py with statement,
+and has totally different semantics.)
+
+
+The play and queue statements now take optional loop and noloop
+modifiers, which force looping (or lack of looping) on that channel.
+The play statement takes an if_changed modifier, which prevents a song
+from being restarted if it is already playing on the channel. [doc]
+
+
+Ren'Py now allows save games to be deleted. To do this, select a save
+game (either with the keyboard, or by hovering the mouse over it), and
+hit delete.
+
+
+Buttons now take a keymap argument, which specifies an alternate 
+keymap that is used when the button is focused.
+
+
+Added the Image Location Picker to the Developer (shift+D) menu. This
+tool lets the user pick an image, and then pick locations that
+image. It displays the mouse coordinates, imagemap rectangle, and
+cropping rectangle.
+
+
+Added a FPS meter to the Developer (shift+D) menu.
+
+Added a .001s sleep for frames that are framerate-limited. This should
+prevent Ren'Py from consuming all CPU unless the game is CPU-bound.
+
+
+Added config.file_open_callback, which allows Ren'Py to load files
+from user-definable archive types.
+
+
+Added the renpy.get_roll_forward function, which is the infrastructure
+needed to create a button that lets the user roll forward.
+
+
+Changed MoveTransition to preserve the timebases of the thing being moved
+in all circumstances.
+
+
+Ren'Py is now built using SDL-1.2.13. On Linux systems with pulseaudio
+support, it will use pulseaudio for audio output.
+
+
+Fixed a bug with archive files that could cause crashing in some 
+circumstances.
+
+Fixed a bug that prevented {w=1} from working.
+
+Fixed a bug that prevented style.rebuild from working.
+
+Fixed a potential segfault bug with certain transforms, zooms, and
+rotations.
+
+
+New in Ren'Py 6.9.3
+-------------------
+
+This release includes Launcher2, a near-total rewrite of the Ren'Py
+launcher. Among the more important changes are:
+
+* The launcher now supports a project directory. It is no longer
+necessary to move projects around when upgrading Ren'Py.
+
+* The launcher has support for selecting the editor to use. While we
+ship with jEdit support, other editors can be downloaded from the
+Ren'Py web site.
+
+* When building distributions, the launcher now allows the user to
+choose which distributions are built.
+
+* The Macintosh distribution now places all non-documentation files
+inside a single application.
+
+* There is a new combined distribution, which includes support for
+Windows, Linux, and Macintosh in a single zip file.
+
+
+The new ui.detached function allows one to use the ui functions to
+define displayables without adding them to a layer.
+
+
+Ren'Py will now search for a directory named "Ren'Py Data" in the
+directories above your Ren'Py installation. If found, save data will
+be placed in that directory, rather than the system-specific default
+location. This should help make it easier to develop Ren'Py games when
+using a USB drive.
+
+
+The save location for screenshots has now been standardized. It is now
+the directory containing the executable used to start Ren'Py, be it a
+.exe, .py, .sh, or .app. (The latter is handled specially.)
+
+
+Allow config.layer_clipping to specify layers that are larger than the
+screen.
+
+
+The various layouts now change the mouse to the gamemenu or mainmenu
+mouse, as appropriate.
+
+
+This distribution include a new NVL-mode tutorial, teaching people how
+to make NVL-mode games.
+
+
+Fixed a long-standing problem that could cause Rollback to operate
+incorrectly with object that were unreachable at the time of the
+Rollback.
+
+Fixed a problem that prevented animations from displaying correctly
+when the animation was displayed more than once.
+
+Fixed a problem that could cause children of the various
+MultiBox-based displayables (Fixed, HBox, VBox, and LiveComposite) to
+display animations incorrectly.
+
+
+New in Ren'Py 6.9.2
+-------------------
+
+The semantics for play and queue have changed slightly. Now, when a
+play statement is followed by one or more queue statements, the first 
+file in each play or queue statement will be played. For example:
+
+play music "a.ogg"
+queue music "b.ogg"
+queue music "c.ogg"
+
+will play "a.ogg", "b.ogg", and then loop "c.ogg". This change also
+applies to renpy.music.play and renpy.music.queue.
+
+
+Rollback was changed so that doing anything other than a roll-forward
+while in rollback mode exits rollback immediately.
+
+
+The library alias for config has been removed.
+
+
+Fixed a regression that caused dissolves to be terribly slow.
+
+Fixed a bug that caused Ren'Py to crash when playing music on Windows
+when Data Execution Prevention was enabled. DEP is enabled by default
+on 64-bit Windows Vista.
+
+Fixed a bug that caused Ren'Py to crash when a window icon was used on
+a computer with a 16-bit or 8-bit screen depth.
+
+Fixed a bug that caused ui.sizer to malfunction.
+
+Fixed a repeated word in "The Question".
+
+Fixed a bug that could cause it to take two tries to define a joystick 
+button.
+
+
+
+New in Ren'Py 6.9.1
+-------------------
+
+The music and video playback code has been completely rewritten. The
+new implementation uses the ffmpeg library. It includes the following
+features:
+
+* Support for ogg, mp3, mp2, wav, and flac audio.
+
+* Support for theora, mpeg4 part 2 (including DivX and Xvid), mpeg2,
+  and mpeg1 video.
+
+* Support for an arbitrary number of named channels, replacing the
+  previous eight numbered channels.
+
+* Audio files are now automatically converted to the output sampling
+  rate (by default, 44100hz). This prevents the problems that would
+  previously crop up when playing audio sampled at other rates.
+
+* The play, queue, and stop statements now take a channel name as the
+  second argument, which makes using user-defined channels easier. 
+
+As part of this rewrite, we have eliminated support for mod formats,
+as they are not supported by ffmpeg.
+
+Please read the reference manual documentation for Audio and Movies to
+learn the new interface.
+
+The new code requires some changes in the saved data. As a result,
+loading a file saved with a prior version of Ren'Py may lead to a lack
+of music until the next track is played.
+
+
+
+The new window statement allows one to control if an empty window is
+shown when no character is speaking. Specifically, the
+
+window show [transition]
+
+statement shows the window, and the 
+
+window hide [transition]
+
+statement hides it. Both can take an optional
+transition. config.empty_window is responsible for displaying the
+window, while config.window_show_transition and
+config.window_hide_transition are default transitions. The state of
+the window can be determined by testing _window. The
+renpy.shown_window function can be called to suppress displaying the
+empty window, and is called automatically when characters speak.
+
+
+Hotspots for the game menu buttons can be defined as part of
+layout.imagemap_load_save, layout.imagemap_preferences, and
+layout.imagemap_yesno_prompt. Doing so prevents layout.navigation from
+being called for that screen. It also allows opaque imagemaps to be
+used, rather than forcing them to be transparent to allow the
+navigation to show through.
+
+
+There is a new config.windows_icon variable, that lets one set the
+window icon for Windows separately from Mac OS X and Linux.
+
+
+Ren'Py now automatically scales itself down when it detects that the
+game window is too large for the screen.
+
+
+The define.move_transitions function can now pass keyword arguments to
+the moves it creates. The most useful thing with this is to pass
+subpixel=True, in order to create subpixel move transitions.
+
+
+The Motion (including Move and Pan), Zoom, RotoZoom, and FactorZoom
+displayables now use the style.motion style, which now has xanchor and
+yanchor both set to 0. This gives these movements the same semantics
+when used inside an image clause as they have outside one.
+
+
+im.Grayscale and im.Sepia now take properties, so they can be
+positioned.
+
+
+The new renpy.get_placement function returns information about the
+placement of displayables.
+
+
+Improved the render management code, so there should no longer be any
+leaks reported during shutdown.
+
+
+Deal with the case where a bmfont has a negative offset for the first
+character in a string.
+
+
+Added more verbose diagnostics when illegal statements are run in the
+init phase.
+
+
+Added _rollback, which controls if rollback is enabled.
+
+
+Added a target parameter to renpy.full_restart, which allows the main
+menu screen to be selected after a restart.
+
+
+
+Fixed a bug that caused layout.imagemap_main_menu to call a label even
+though there was a button with the same name.
+
+Fixed a bug that prevented Zoom from working in non-bilinear mode.
+
+Fixed a bug that could cause buttons not not consume events when using
+an imagemap main menu.
+
+Fixed a bug that caused Transform to produce an incorrectly-sized
+render.
+
+Fixed a bug that could cause crashing when rolling back to a Zoom with
+an after_child.
+
+Fixed a bug that could cause segfaults when saving overly-complicated
+images.
+
+
+New in Ren'Py 6.9.0
+-------------------
+
+This release features a rewritten rendering system. The rendering
+subsystem is what manages drawing to the screen. There have been
+several major improvements:
+
+* The render system has been simplified. Although still complex, it's 
+  now easier to understand than the old system, while also being
+  naturally a bit faster.
+
+* That being said, the render system now focuses more on framerate
+  consistency than raw speed. 
+
+* The render system now supports subpixel drawing, drawing images at
+  locations that are not integer pixel boundaries. This is enabled by
+  setting the subpixel style property to True for a displayable. (It 
+  makes the most sense to do this for Move and Pan, and less sense to
+  do this for non-moving displayables.) 
+
+* The render system supports specifying subpixel placement of
+  displayables. This is done using the new absolute type. (A
+  floating-point position is still interpreted as a fraction of the
+  area in which the displayable is placed.)
+
+* The render system supports a rotate-zoom-alpha mode, in which allows
+  a displayable to be rotated, zoomed, and have its alpha
+  changed. When this mode is used, the cost remains constant, even
+  when multiple transformations are composed. Currently, this is only
+  used by Transform and ui.transform.
+
+* The render system supports rotating and scaling focusable objects.
+
+Improved the transform routine used by RotoZoom and Transform. It's
+now both more accurate and faster. On Intel computers, it is now
+accelerated using MMX instructions.  
+
+
+The image statement now implicitly places itself inside an init block
+if it's not inside an init block to begin with. The code:
+
+image bg world = "world.jpg"
+
+is now equivalent to:
+
+init 990:
+    image bg world = "world.jpg"
+
+
+When compiling python blocks containing strings with a unicode
+character in them, Ren'Py will automatically prepend a u to any string
+that's missing it. This should make life easier for users of non-ASCII
+languages.
+
+
+The new ui.autobar function makes it easy to make a bar that 
+varies between two values over time.
+
+
+The new renpy.Container class can be subclassed to create a user-defined 
+displayable thatr contains other displayables, like Transforms.
+
+
+The new im.FactorScale image manipulator allows images to be scaled by
+a specified factor at preload time. This is generally faster than doing the
+equivalent scaling at display time with FactorZoom.
+
+
+The new renpy.sound.set_pan function allows sound and music to be
+smoothly panned over time.
+
+
+The new config.label_callback variable allows a function to be called
+whenever control reaches a label. It can distinguish between jumps to
+that label and control falling through.
+
+
+There have been a couple of places where properly documented functions
+have superseded semi-documented calls into the Ren'Py internals:
+
+The renpy.game_menu and ui.gamemenus functions are now the preferred ways
+of getting access to the game menu.
+
+The ui.jumps function now takes a transition argument, allowing it to subsume
+the undocumented _intra_jumps.
+
+
+Ren'Py now looks for the file environment.txt in the directory
+containing Ren'Py itself. If it finds it, it loads the file as a
+python file, and uses it to set the default values of environment
+variables. This allows things like the editor or the scale factor to
+be set even on platforms that don't make it easy to change environment
+variables globally.
+
+
+The reporting of parse errors involving missing quotes has been
+improved.
+
+
+Changed the behavior of overlays during transitions. Now, both the old
+and new screens will use the new overlay. Previously, the overlay was
+cleared out during a transition, which didn't work well, as (for
+example) a dissolve would cause the overlay to blink out and then
+dissolve back in again.
+
+
+MoveTransition and define.move_transitions have been changed to take 
+a layers argument, giving the list of layers the transition applies
+to. By default, this is only the master layer, which is a change in
+their behavior.
+
+
+Calling theme.roundrect() no longer implies layout.button_menu(). 
+
+
+Ren'Py now autosaves when entering the quit prompt, and will not actually 
+quit until this autosave is complete. 
+
+
+The default framerate limit (config.framerate) has been raised to
+100fps. This make tearing less noticable than on a 60hz screen.
+
+
+Added renpy.partial as a version of renpy.curry that requires two
+function calls, rather than three.
+
+
+Fixed a divide by zero error that occured when Alpha was used for 0
+seconds.
+
+
+Libvorbis has been upgraded to version 1.2.0.
+
+
+To reduce distribution size, OGG Speex support was dropped.
+
+
+New in Ren'Py 6.8.1
+-------------------
+
+Added support for the iRex iLiad ebook reader platform.  This required
+adding the following features, which may prove useful for other
+platforms:
+
+Added support for the RENPY_SCALE_WIDTH environment variable, which
+allows the game to be scaled to a specific width, if it's larger.
+
+Added support for the RENPY_LESS_MEMORY environment variable, which
+reduces the amount of memory used by Ren'Py in exchanged for reduced
+speed.
+
+Added support for the RENPY_LESS_UPDATES environment variable, which
+tries to reduce the number of screen updates to one per interaction.
+
+Added support for the RENPY_LESS_MOUSE environment variable, which 
+prevents the mouse from being shown.
+
+The iLiad support was sponsored by Hixbooks.
+
+
+It is now possible to rebuild the distribution of a game by unzipping 
+it underneath the Ren'Py directory, selecting it as a project, and 
+building the distributions. This makes it easy to upgrade the version
+of Ren'Py used by a game, or to build a version of it that works on
+your favorite platform.
+
+
+The new Alpha function can be used to change the alpha level of a
+displayable. (im.Alpha can only be used with other image
+manipulators.)
+
+
+User-defined statements are now documented in the reference manual,
+making them officially supported.
+
+A user-defined statement can now be used as the default
+statement. This allows you to replace the say statement with an
+alternate of your own devising.
+
+
+Fixed a bug that occured when space characters were inserted
+immediately after a newline.
+
+Fixed a problem displaying a presplash image on the mac platform.
+
+
 New in Ren'Py 6.8.0
 -------------------
 
@@ -21,6 +727,12 @@ to have additional whitespace inserted between words so that the left
 and right margins are even, except on the last line of a paragraph.
 
 
+Ren'Py now supports the MudgeFont and BMFont image-based font file
+formats. The new renpy.register_mudgefont function is used to register
+a MudgeFont, and the renpy.register_bmfon function is used to register
+a BMFont.
+
+
 Newly-created games will have a Help option on the main and game
 menus. This is controlled by the config.help variable. By default 
 the help system shows the README.html file in the game's base directory.
@@ -48,9 +760,10 @@ Game", for consistency with the game menu.
 
 When config.developer is set and an undefined image is used in a show
 or scene statement, a list of undefined images will appear centered at
-the top of the screen. A black screen will be show instead of any missing
-background. This makes it easier to write a script before all images are
-present.
+the top of the screen. A black screen (configurable with
+config.missing_background) will be shown instead of any missing
+background. This makes it easier to write a script before all images
+are present.
 
 
 The newly-documented Style.set_parent method lets you change the
@@ -74,7 +787,7 @@ Alt-F4 and Command-Q now trigger the quit event, as if you pressed the
 quit button on the top of the window. The first press brings up the 
 quit prompt, and a second press forcibly terminates the game. 
 
-Alt-H and Command-H hide (iconify) the window.
+Alt-M and Command-M iconify the window.
 
 
 The new RENPY_SCREENSHOT_PATTERN environment variable lets you
@@ -91,6 +804,10 @@ The presplash code now looks for presplash.jpg in the game directory
 if presplash.png is not found.
 
 
+On Windows, config.window_icon will be scaled to 32x32 if it is wider
+than 32 pixels. This allows the same icon to be used across platforms.
+
+
 Custom mouse cursors should now be properly hidden when the mouse
 leaves the window. Previously, this failed to work on the Mac OS X
 platform.
@@ -4077,4 +4794,3 @@ controls which transitions are performed.
 
 Added a Pan function which can be used in an at clause. This allows us
 to pan over a background image.
-

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

@@ -5,6 +5,8 @@ if [ "x$1" = "x" ]; then
     exit
 fi
 
+rsync -av updates tom@onegeek.org:/home/tom/WWW.update/renpy/
+
 mkdir ~/ab/website/renpy/dl/$1
 cp dists/renpy-$1-* ~/ab/website/renpy/dl/$1
 cp CHANGELOG.txt ~/ab/website/renpy/dl/$1

build_exe.bat

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

build_exe.py

@@ -1,34 +1,55 @@
 #!/usr/bin/env python
 
+import modulefinder
+import shutil
 from distutils.core import setup
 import py2exe
 import sys
 import zipfile
 import traceback
+import os
 
 # The pythonpath on my system.
-sys.path.insert(0, 'c:\\msys\\1.0\\newbuild25\\install\\bin')
-sys.path.insert(0, 'c:\\msys\\1.0\\newbuild25\\install\\python')
+sys.path.insert(0, 'c:\\msys\\1.0\\newbuild\\install\\bin')
+sys.path.insert(0, 'c:\\msys\\1.0\\newbuild\\install\\python')
+
+def move_from_dist(fn):
+    """
+    Moves the file `fn` from the dist directory to the main
+    directory. (This means we don't need symlinks on windows.)
+    """
+
+    if os.path.isdir(fn):
+        shutil.rmtree(fn)
+    elif os.path.exists(fn):
+        os.unlink(fn)
+
+    os.rename("dist/" + fn, fn)
+
+import renpy
+renpy.setup_modulefinder(modulefinder)
 
 def main():
 
-    sys.argv[1:] = [ 'py2exe', '--bundle', '2', '-a', '--dll-excludes', 'w9xpopen.exe', ]
-    # sys.argv[1:] = [ 'py2exe', '-a', '--dll-excludes', 'w9xpopen.exe', ]
+    sys.argv[1:] = [ 'py2exe', '-a', '--dll-excludes', 'w9xpopen.exe', ]
 
-    setup(name="RenPy",
+    setup(name="Ren'Py",
           windows=[ dict(script="renpy.py",
                          dest_base="renpy",
-                         icon_resources=[ (1, "newicon.ico") ] ) ],
+                         icon_resources=[ (1, "newicon.ico") ],
+                         ),
+                    ],
 
           console=[ dict(script="renpy.py", dest_base="console") ],
 
-          zipfile='renpy.code',
+          zipfile='lib/windows-x86/renpy.code',
 
           options={ 'py2exe' : { 'excludes' : [ 'doctest',
                                                 'pygame.macosx',
                                                 'pygame.surfarray',
                                                 'pygame.mixer',
                                                 'pygame.mixer_music',
+                                                'pygame.font',
                                                 '_ssl',
                                                 '_hashlib',
                                                 'win32con',
@@ -45,18 +66,25 @@ def main():
           )
 
 
-    zfold = zipfile.ZipFile("dist/renpy.code")
-    zfnew = zipfile.ZipFile("renpy.code", "w", zipfile.ZIP_STORED)
+    zfold = zipfile.ZipFile("dist/lib/windows-x86/renpy.code")
+    zfnew = zipfile.ZipFile("dist/lib/windows-x86/renpy.code.new", "w", zipfile.ZIP_STORED)
 
     seen = { }
 
     for fn in zfold.namelist():
         if fn.startswith("renpy/"):
-            continue
+
+            # Keep around .pyo files that load pyd files.
+            pydfn = fn.replace("/", ".").replace(".pyo", ".pyd")
+            if not os.path.exists("dist/lib/windows-x86/" + pydfn):
+                continue
 
         if fn in seen:
             continue
 
+        if fn == "SDL_mixer.dll":
+            continue
+        
         seen[fn] = True
 
         zfnew.writestr(fn, zfold.read(fn))
@@ -64,11 +92,21 @@ def main():
     zfold.close()
     zfnew.close()
 
+    os.unlink("dist/lib/windows-x86/renpy.code")
+    os.rename("dist/lib/windows-x86/renpy.code.new", "dist/lib/windows-x86/renpy.code")
+
+    shutil.copy("c:/Python26/Microsoft.VC90.CRT.manifest", "Microsoft.VC90.CRT.manifest")
+    shutil.copy("c:/Python26/msvcr90.dll", "msvcr90.dll")
+
+    move_from_dist("lib/windows-x86")
+    move_from_dist("console.exe")
+    move_from_dist("python26.dll")
+    move_from_dist("renpy.exe")
+    
+    
 try:
     main()
 except:
     traceback.print_exc()
 
-print
-print "Press return to quit."
-raw_input()
+    

build_strings.py

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

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/00atl.rpy

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

common/00compat.rpy

@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init -1210 python:
 
     # This is called when script_version is set, to immediately
@@ -13,6 +16,41 @@ init -1210 python:
         if version <= (6, 5, 0):
             layout.compat()
 
+        if version <= (6, 9, 1):
+            store.library = store.config
+
+        if version <= (6, 9, 3):
+
+            # Before 6.10, these were positions, rather than transforms.
+            store.left = Position(xalign=0.0)
+            store.center = Position(xalign=0.5)
+            store.truecenter = Position(xalign=0.5, yalign=0.5)
+            store.right = Position(xalign=1.0)
+            store.offscreenleft = Position(xpos=0.0, xanchor=1.0)
+            store.offscreenright = Position(xpos=1.0, xanchor=0.0)
+
+        if version <= (6, 10, 2):
+            # Before 6.11, we used the image placement to handle
+            # the location of things on the screen.            
+            style.image_placement.xpos = 0.5
+            style.image_placement.ypos = 1.0
+            style.image_placement.xanchor = 0.5
+            style.image_placement.yanchor = 1.0
+
+            config.transform_uses_child_position = False
+            config.default_transform = None
+            config.start_scene_black = True
+            
+        if version <= (6, 11, 0):
+            config.movetransition_respects_offsets = False
+
+        if version <= (6, 11, 2):
+            config.imagereference_respects_position = True
+            config.predict_screens = False
+            config.choice_screen_chosen = False
+            
+            
+          
 init 1210 python hide::
 
     # This returns true if the script_version is <= the
@@ -54,6 +92,9 @@ init 1210 python hide::
     if compat(6, 2, 0):
         config.reject_backslash = False
 
+    if compat(6, 9, 0):
+        style.motion.clear()
+        
     if "Fullscreen" in config.translations:
         fs = _("Fullscreen")
         config.translations.setdefault("Fullscreen 4:3", fs + " 4:3")

common/00definitions.rpy

@@ -1,27 +1,51 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 # This file contains a number of definitions of standard
 # locations and transitions. We've moved them into the common
 # directory so that it's easy for an updated version of all of these
 # definitions.
 
+init -1110:
+
+    transform reset:
+        alpha 1 rotate None zoom 1 xzoom 1 yzoom 1 align (0, 0) alignaround (0, 0) subpixel False size None crop None 
+   
+    # These are positions that can be used inside at clauses. We set
+    # them up here so that they can be used throughout the program.
+    transform left:
+        xpos 0.0 xanchor 0.0 ypos 1.0 yanchor 1.0
+
+    transform right:
+        xpos 1.0 xanchor 1.0 ypos 1.0 yanchor 1.0
+
+    transform center:
+        xpos 0.5 xanchor 0.5 ypos 1.0 yanchor 1.0
+
+    transform truecenter:
+        xpos 0.5 xanchor 0.5 ypos 0.5 yanchor 0.5
+        
+    # Offscreen positions for use with the move transition. Images at
+    # these positions are still shown (and consume
+    # resources)... remember to hide the image after the transition.    
+    transform offscreenleft:
+        xpos 0.0 xanchor 1.0 ypos 1.0 yanchor 1.0
+
+    transform offscreenright:
+        xpos 1.0 xanchor 0.0 ypos 1.0 yanchor 1.0
+
+    transform default:
+        alpha 1 rotate None zoom 1 xzoom 1 yzoom 1 align (0, 0) alignaround (0, 0) subpixel False size None crop None 
+        xpos 0.5 xanchor 0.5 ypos 1.0 yanchor 1.0
+
+    python:
+        config.default_transform = default
+        
+
 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.
@@ -62,60 +86,69 @@ init -1110 python:
         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):
+    def move_transitions(prefix, delay, time_warp=None, in_time_warp=None, out_time_warp=None, old=False, layers=[ 'master' ], **kwargs):
         moves = {
             "" : MoveTransition(
                 delay,
                 old=old,
-                factory=MoveFactory(time_warp=time_warp)),
+                layers=layers,
+                factory=MoveFactory(time_warp=time_warp, **kwargs)),
 
             "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)),
+                layers=layers,
+                factory=MoveFactory(time_warp=time_warp, **kwargs), 
+                enter_factory=MoveIn((1.0, None, 0.0, None), time_warp=in_time_warp, **kwargs)),
 
             "inleft" : MoveTransition(
                 delay,
                 old=old,
-                factory=MoveFactory(time_warp=time_warp), 
-                enter_factory=MoveIn((0.0, None, 1.0, None), time_warp=in_time_warp)),
+                layers=layers,
+                factory=MoveFactory(time_warp=time_warp, **kwargs), 
+                enter_factory=MoveIn((0.0, None, 1.0, None), time_warp=in_time_warp, **kwargs)),
 
             "intop" : MoveTransition(
                 delay,
                 old=old,
-                factory=MoveFactory(time_warp=time_warp), 
-                enter_factory=MoveIn((None, 0.0, None, 1.0), time_warp=in_time_warp)),
+                layers=layers,
+                factory=MoveFactory(time_warp=time_warp, **kwargs), 
+                enter_factory=MoveIn((None, 0.0, None, 1.0), time_warp=in_time_warp, **kwargs)),
 
             "inbottom" : MoveTransition(
                 delay,
                 old=old,
-                factory=MoveFactory(time_warp=time_warp), 
-                enter_factory=MoveIn((None, 1.0, None, 0.0), time_warp=in_time_warp)),
+                layers=layers,
+                factory=MoveFactory(time_warp=time_warp, **kwargs),
+                enter_factory=MoveIn((None, 1.0, None, 0.0), time_warp=in_time_warp, **kwargs)),
 
             "outright" : MoveTransition(
                 delay,
                 old=old,
-                factory=MoveFactory(time_warp=time_warp), 
-                leave_factory=MoveOut((1.0, None, 0.0, None), time_warp=out_time_warp)),
+                layers=layers,
+                factory=MoveFactory(time_warp=time_warp, **kwargs), 
+                leave_factory=MoveOut((1.0, None, 0.0, None), time_warp=out_time_warp, **kwargs)),
 
             "outleft" : MoveTransition(
                 delay,
                 old=old,
-                factory=MoveFactory(time_warp=time_warp), 
-                leave_factory=MoveOut((0.0, None, 1.0, None), time_warp=out_time_warp)),
+                layers=layers,
+                factory=MoveFactory(time_warp=time_warp, **kwargs), 
+                leave_factory=MoveOut((0.0, None, 1.0, None), time_warp=out_time_warp, **kwargs)),
 
             "outtop" : MoveTransition(
                 delay,
                 old=old,
-                factory=MoveFactory(time_warp=time_warp), 
-                leave_factory=MoveOut((None, 0.0, None, 1.0), time_warp=out_time_warp)),
+                layers=layers,
+                factory=MoveFactory(time_warp=time_warp, **kwargs), 
+                leave_factory=MoveOut((None, 0.0, None, 1.0), time_warp=out_time_warp, **kwargs)),
 
             "outbottom" : MoveTransition(
                 delay,
                 old=old,
-                factory=MoveFactory(time_warp=time_warp), 
-                leave_factory=MoveOut((None, 1.0, None, 0.0), time_warp=time_warp)),
+                layers=layers,
+                factory=MoveFactory(time_warp=time_warp, **kwargs), 
+                leave_factory=MoveOut((None, 1.0, None, 0.0), time_warp=time_warp, **kwargs)),
             }
 
         for k, v in moves.iteritems():
@@ -131,8 +164,6 @@ init -1110 python:
     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.
@@ -156,3 +187,7 @@ init 1110 python:
 
     if not hasattr(store, 'centered'):
         centered = Character(None, what_style="centered_text", window_style="centered_window")
+
+    # This is necessary to ensure that config.default_transform works.
+    if config.default_transform:
+        config.default_transform._show()

common/00gltest.rpy

@@ -0,0 +1,188 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# This contains code to choose between OpenGL and Software rendering, when
+# a system supports both.
+
+init -1024:
+    screen _gl_test:
+        frame:
+            xalign .5
+            yalign .33
+
+            xpadding 20
+            ypadding 20
+
+            has vbox
+
+            label _(u"Graphics Acceleration")
+
+            null height 10
+            
+            textbutton _(u"Automatically Choose"):
+                size_group "gl"
+                action SetField(persistent, "_gl_test", "auto")
+            textbutton _(u"Prefer Software Renderer"):
+                size_group "gl"
+                action SetField(persistent, "_gl_test", "sw")
+            textbutton _(u"Prefer OpenGL Renderer"):
+                size_group "gl"
+                action SetField(persistent, "_gl_test", "gl")
+
+            null height 10
+
+            textbutton _(u"Continue"):
+                size_group "gl"
+                action Return(True)
+
+init -1024 python:
+    # The image that we fill the screen with in GL-test mode.
+    config.gl_test_image = "black"
+
+    class __GLTest(renpy.Displayable):
+        """
+         This counts the number of times it's been rendered, and
+         the number of seconds it's been displayed, and uses them
+         to make the decisions as to if OpenGL is working or not.
+         """
+        
+        def __init__(self, frames, fps, timeout):
+            super(__GLTest, self).__init__()
+
+            self.target = 1.0 * frames / fps
+            self.frames = frames
+            self.timeout = timeout
+
+            self.times = [ ]
+            self.success = False
+            
+        def render(self, width, height, st, at):
+            self.times.append(st)
+
+            renpy.redraw(self, 0)
+
+            renpy.renpy.log.info("Frame drawn at %f seconds." % st)
+            
+            if len(self.times) >= self.frames:
+                frames_timing = self.times[-1] - self.times[-self.frames]
+
+                renpy.renpy.log.info("It took %f seconds to render %d frames.", frames_timing, self.frames)
+
+                if frames_timing <= self.target:
+                    self.success = True
+                    renpy.timeout(0)
+                    
+            rv = renpy.Render(width, height)
+            return rv
+                            
+        def event(self, ev, x, y, st):
+
+            if self.success:
+                return True
+
+            if st > self.timeout:
+                return False
+
+            renpy.timeout(self.timeout - st)
+
+
+    def __gl_prefer_renderers(renderers):
+        """
+         Forces the current renderer to be renderer, one of gl or sw.
+         """
+
+        if renpy.display.prefer_renderers == renderers:
+            return
+
+        renpy.display.prefer_renderers = renderers        
+        renpy.display_reset()
+                    
+    def __gl_prompt():
+        """
+         Decides if we want to prompt the user to enable OpenGL mode.
+         If so, shows a screen that allows the user to alter the
+         OpenGL setting.
+         """
+
+        if not renpy.display.interface.safe_mode:
+            return 
+
+        __gl_prefer_renderers("sw")
+        
+        renpy.call_screen("_gl_test")
+
+        renpy.display.interface.safe_mode = False
+        
+    def __gl_test():
+        """
+         Makes the decision as to if we should use GL or SW mode.
+         """
+
+        import os
+        if "RENPY_RENDERER" in os.environ:
+            return
+
+        # Our decision survives a restart.
+        if _restart:
+            return
+
+        renpy.renpy.log.info("GL test mode: %s", persistent._gl_test)
+
+        # If GL is disabled, don't bother.
+        if not config.gl_enable:
+            return
+        
+        __gl_prompt()
+
+        if persistent._gl_test == "gl":
+            __gl_prefer_renderers("gl,sw")
+            return
+
+        if persistent._gl_test == "sw":
+            __gl_prefer_renderers("sw")
+            return
+
+        __gl_prefer_renderers("gl,sw")
+
+        ui.pausebehavior(0)
+        ui.interact(suppress_underlay=True, suppress_overlay=True)
+
+        # If GL is able to render FRAMES frames at FPS fps in less
+        # than DELAY seconds, we consider it to be operational, and
+        # continue in GL mode. Otherwise, we rever to software
+        # rendering mode.
+        FRAMES = 5
+        FPS = 15
+        DELAY = 1
+        
+        renpy.transition(Dissolve(DELAY), always=True, force=True)
+        ui.add(__GLTest(FRAMES, FPS, DELAY))
+        result = ui.interact(suppress_overlay=True, suppress_underlay=True)
+
+        if result:
+            __gl_prefer_renderers("gl,sw")
+        else:
+            __gl_prefer_renderers("sw")
+
+    # Init-time code:
+    # Make a guess as to what modes we should be in.
+    if persistent._gl_test is None:
+        persistent._gl_test = "auto"
+
+    if persistent._gl_test == "sw":
+        renpy.display.prefer_renderers = "sw"
+        
+            
+label _gl_test:
+
+    # Show the test image.
+    scene
+    show expression config.gl_test_image
+    
+    $ __gl_test()
+                
+    # Hide the test image.
+    scene
+
+    return
+

common/00layout.rpy

@@ -1,7 +1,5 @@
-# Copyright 2004-2007 PyTom
-#
-# Please see the LICENSE.txt distributed with Ren'Py for permission to
-# copy and modify.
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
 
 init -1105 python:
 
@@ -16,17 +14,6 @@ init -1105 python:
     layout.compat_funcs = [ ]
     layout.provided = set()
     
-    # This takes care of actually displaying button menus.
-    def _display_button_menu(menuitems):
-
-        narration = [ s for s, i in menuitems if i is None and s ]
-        menuitems = [ (s, i) for s, i in menuitems if i is not None or not s ]
-
-        if narration:
-            renpy.say(None, "\n".join(narration), interact=False)
-
-        return renpy.display_menu(menuitems)
-
 init -1105 python hide:
 
     # Called to indicate that the given kind of layout has been
@@ -58,6 +45,21 @@ init -1105 python hide:
             joystick_preferences=layout.classic_joystick_preferences,
             )
 
+        if renpy.has_screen("main_menu"):
+            defaults["main_menu"] = layout.screen_main_menu
+
+        if renpy.has_screen("load") and renpy.has_screen("save"):
+            defaults["load_save"] = layout.screen_load_save
+
+        if renpy.has_screen("yesno_prompt"):
+            defaults["yesno_prompt"] = layout.screen_yesno_prompt
+
+        if renpy.has_screen("preferences"):
+            defaults["preferences"] = layout.screen_preferences
+
+        if renpy.has_screen("joystick_preferences"):
+            defaults["joystick_preferences"] = layout.screen_joystick_preferences
+        
         for k, v in defaults.iteritems():
             if k not in layout.provided:
                 v()
@@ -198,7 +200,7 @@ init -1105 python hide:
     @layout
     def button_menu():
 
-        store.menu = _display_button_menu
+        config.narrator_menu = True
 
         style.menu.box_spacing = 2
         style.menu_window.set_parent(style.default)
@@ -288,13 +290,14 @@ init -1105 python hide:
 
 
     @layout
-    def imagemap_main_menu(ground, selected, hotspots):
+    def imagemap_main_menu(ground, selected, hotspots, idle=None, variant=None):
         renpy.load_module("_layout/imagemap_main_menu")
 
-        config.main_menu_ground = ground
-        config.main_menu_selected = selected
-        config.main_menu_hotspots = hotspots
-
+        config.main_menu_ground[variant] = ground
+        config.main_menu_selected[variant] = selected
+        config.main_menu_hotspots[variant] = hotspots
+        config.main_menu_idle[variant] = idle
+        
     @layout
     def imagemap_navigation(ground, idle, hover, selected_idle, selected_hover,
                             hotspots):
@@ -322,7 +325,7 @@ init -1105 python hide:
         config.preferences_hotspots = hotspots
 
     @layout
-    def imagemap_yesno_prompt(ground, idle, hover, hotspots):
+    def imagemap_yesno_prompt(ground, idle, hover, hotspots, prompt_images={ }):
 
         renpy.load_module("_layout/imagemap_yesno_prompt")
         
@@ -330,16 +333,91 @@ init -1105 python hide:
         config.yesno_prompt_idle = idle
         config.yesno_prompt_hover = hover
         config.yesno_prompt_hotspots = hotspots
+        config.yesno_prompt_message_images = prompt_images
         
     @layout
     def imagemap_load_save(ground, idle, hover, selected_idle, selected_hover,
-                           hotspots):
+                           hotspots, variant=None):
 
         renpy.load_module("_layout/imagemap_load_save")
         
-        config.load_save_ground = ground
-        config.load_save_idle = idle
-        config.load_save_hover = hover
-        config.load_save_selected_idle = selected_idle
-        config.load_save_selected_hover = selected_hover
-        config.load_save_hotspots = hotspots
+        config.load_save_ground[variant] = ground
+        config.load_save_idle[variant] = idle
+        config.load_save_hover[variant] = hover
+        config.load_save_selected_idle[variant] = selected_idle
+        config.load_save_selected_hover[variant] = selected_hover
+        config.load_save_hotspots[variant] = hotspots
+
+    @layout
+    def screen_main_menu():
+        renpy.load_module("_layout/screen_main_menu")
+        
+    @layout
+    def screen_load_save():
+        renpy.load_module("_layout/screen_load_save")
+        
+    @layout
+    def screen_preferences():
+        renpy.load_module("_layout/screen_preferences")
+        
+    @layout
+    def screen_joystick_preferences():
+        renpy.load_module("_layout/screen_joystick_preferences")
+        
+    @layout
+    def screen_yesno_prompt():
+        renpy.load_module("_layout/screen_yesno_prompt")
+    
+    layout.ARE_YOU_SURE = u"Are you sure?"
+    layout.DELETE_SAVE = u"Are you sure you want to delete this save?"
+    layout.OVERWRITE_SAVE = u"Are you sure you want to overwrite your save?"
+    layout.LOADING = u"Loading will lose unsaved progress.\nAre you sure you want to do this?"
+    layout.QUIT = u"Are you sure you want to quit?"
+    layout.MAIN_MENU = u"Are you sure you want to return to the main menu?\nThis will lose unsaved progress."
+
+    @layout
+    def yesno_screen(message, yes=None, no=None):
+        """
+         :doc: other
+
+         This causes the a yes/no prompt screen with the given message
+         to be displayed. The screen will be hidden when the user hits
+         yes or no.
+
+         `message`
+             The message that will be displayed.
+
+         `yes`
+             An action that is run when the user chooses yes.
+
+         `no`
+             An action that is run when the user chooses no.
+         """
+
+        if renpy.has_screen("yesno_prompt"):
+
+            yes_action = [ Hide("yesno_prompt") ]
+            no_action = [ Hide("yesno_prompt") ]
+
+            if yes is not None:
+                yes_action.append(yes)
+            if no is not None:
+                no_action.append(no)
+            
+            renpy.show_screen(
+                "yesno_prompt", 
+                message=message,
+                yes_action=yes_action,
+                no_action=no_action)
+
+            renpy.restart_interaction()
+            
+            return
+            
+        if renpy.invoke_in_new_context(layout.yesno_prompt, None, message):
+            if yes is not None:
+                yes()
+        else:
+            if no is not None:
+                no()
+                

common/00library.rpy

@@ -1,7 +1,5 @@
-# Copyright 2004-2007 PyTom
-#
-# Please see the LICENSE.txt distributed with Ren'Py for permission to
-# copy and modify.
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
 
 # This file consists of renpy functions that aren't expected to be
 # touched by the user too much. We reserve the _ prefix for names
@@ -49,6 +47,31 @@ init -1180 python:
     # preference when the game is first run.
     config.default_text_cps = None        
 
+    # If not None, the default value of afm_time
+    config.default_afm_time = None
+
+    # If not None, the default value of afm_enable
+    config.default_afm_enable = None
+    
+    # Should we automatically define images?
+    config.automatic_images = None
+
+    # Prefixes to strip from automatic images.
+    config.automatic_images_strip = [ ]
+    
+    # A save to automatically load, if it exists.
+    config.auto_load = None
+
+    # Layers to clear when entering the menus.
+    config.menu_clear_layers = [ ]
+
+    # Should we start the game with scene black or just scene?
+    config.start_scene_black = False
+
+    # Voice and Sound samples.
+    config.sample_sound = None
+    config.sample_voice = None
+    
     # This is updated to give the user an idea of where a save is
     # taking place.
     save_name = ''
@@ -69,6 +92,24 @@ init -1180 python:
 
     config.with_callback = _default_with_callback
 
+
+    def _default_empty_window():
+
+        who = _last_say_who
+
+        if who is not None:
+            who = eval(who)
+
+        if who is None:
+            who = narrator
+
+        if isinstance(who, NVLCharacter):
+            nvl_show_core()
+        else:
+            store.narrator("", interact=False)
+                
+    config.empty_window = _default_empty_window
+        
     style.skip_indicator = Style(style.default, heavy=True, help='The skip indicator.')
     style.skip_indicator.xpos = 10
     style.skip_indicator.ypos = 10
@@ -80,7 +121,6 @@ init -1180 python:
 
     _intra_jumps = renpy.curry(_intra_jumps_core)
 
-
     # The function that's used to translate strings in the game menu.
     def _(s):
         """
@@ -95,11 +135,33 @@ init -1180 python:
 
         return s
 
+    config.extend_interjection = "{fast}"
+
+    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
+
     # Are the windows currently hidden?
     _windows_hidden = False
 
-init -1180 python:
-
     def toggle_skipping():
 
         if not config.skipping:
@@ -114,47 +176,90 @@ init -1180 python:
 
     config.help = None
             
-    def _help():
-        if not config.help:
+    def _help(help=None):
+
+        if help is None:
+            help = config.help
+
+        if help is None:
             return
 
-        if renpy.has_label(config.help):
-            renpy.call_in_new_context(config.help)
+        if renpy.has_label(help):
+            renpy.call_in_new_context(help)
             return
 
         _preferences.fullscreen = False
-        
-        import webbrowser
-        webbrowser.open_new("file:///" + config.basedir + "/" + config.help)
-        
-    
-init -1180 python hide:
 
+        try:
+            import webbrowser
+            webbrowser.open_new("file:///" + config.basedir + "/" + help)
+        except:
+            pass
+
+        
     # Called to make a screenshot happen.
-    def screenshot():
+    def _screenshot():
         import os.path
         import os
-
-        pattern = os.environ.get("RENPY_SCREENSHOT_PATTERN", "screenshot%04d.png")
+        import __main__
         
+        pattern = os.environ.get("RENPY_SCREENSHOT_PATTERN", "screenshot%04d.png")
+
+        # Pick the directory to save into.
+        dest = config.renpy_base.rstrip("/")
+        
+        # Guess if we're an OSX App.
+        if dest.endswith("/Contents/Resources/autorun"):
+            # Go up 4 directories.
+            dest = os.path.dirname(dest)
+            dest = os.path.dirname(dest)
+            dest = os.path.dirname(dest)
+            dest = os.path.dirname(dest)
+
+        # Try to pick a filename.
         i = 1
         while True:
-            fn = pattern % i
+            fn = dest + "/" + pattern % i
             if not os.path.exists(fn):
                 break
             i += 1
 
-        renpy.screenshot(fn)
+        try:
+            renpy.screenshot(fn)
+        except:
+            import traceback
+            traceback.print_exc()
+
+        if config.screenshot_callback is not None:
+            config.screenshot_callback(fn)
+
+    def _screenshot_callback(fn):
+        renpy.notify(_("Saved screenshot as %s.") % fn)
+
+    config.screenshot_callback = _screenshot_callback
+        
+    _predict_screens = [ ]
+        
+init -1180 python hide:
 
     def dump_styles():
         if config.developer:
             renpy.style.write_text("styles.txt")
 
+    # This is run when entering the game menu.
+    config.game_menu_action = None
+            
     def invoke_game_menu():
         if renpy.context()._menu:
-            renpy.jump("_noisy_return")
+            if renpy.context()._main_menu:
+                return
+            else:
+                renpy.jump("_noisy_return")
         else:
-            renpy.call_in_new_context('_game_menu')
+            if config.game_menu_action:
+                renpy.display.behavior.run(config.game_menu_action)
+            else:            
+                renpy.call_in_new_context('_game_menu')
 
     def keymap_toggle_skipping():
         if renpy.context()._menu:
@@ -182,10 +287,11 @@ init -1180 python hide:
         filename, line = renpy.get_filename_line()
         renpy.launch_editor([ filename ], line)
         
-    # The default keymap.
+    # The default keymap. We might also want to put some of this into
+    # the launcher.
     km = renpy.Keymap(
         rollback = renpy.rollback,
-        screenshot = screenshot,
+        screenshot = _screenshot,
         toggle_fullscreen = renpy.toggle_fullscreen,
         toggle_music = renpy.toggle_music,
         toggle_skip = keymap_toggle_skipping,
@@ -244,32 +350,42 @@ init -1180 python hide:
 
     config.hyperlink_styler = hyperlink_styler
     config.hyperlink_callback = hyperlink_function
+
+    # Prediction of screens.    
+    def predict():
+
+        for s in _predict_screens:
+            if renpy.has_screen(s):
+                renpy.predict_screen(s)
+
+        s = _game_menu_screen
+
+        if s is None:
+            return
+
+        if renpy.has_screen(s):
+            renpy.predict_screen(s)
+            return
+
+        if s.endswith("_screen"):
+            s = s[:-7]
+            if renpy.has_screen(s):
+                renpy.predict_screen(s)
+                return
+
+            
+    config.predict_callbacks.append(predict)
+            
+    def imagemap_auto_function(auto_param, variant):
+        rv = auto_param % variant
+
+        if renpy.loadable(rv):
+            return rv
+        else:
+            return None
         
-
-    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
+    config.imagemap_auto_function = imagemap_auto_function
 
 
 label _hide_windows:
@@ -283,45 +399,26 @@ label _hide_windows:
     python:
         _windows_hidden = True
         ui.saybehavior(dismiss=['dismiss', 'hide_windows'])
-        ui.interact(suppress_overlay=True)
+        ui.interact(suppress_overlay=True, suppress_window=True)
         _windows_hidden = False
 
     return
 
     
 # This code here handles check for the correct version of the Ren'Py module.
-
-label _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))
-                
+        renpy.music.stop()
+        
         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"
+        renpy.save("_reload-1", "reload save game")
         
         ui.add(Solid((0, 0, 0, 255)))
         ui.text("Reloading script...",
@@ -332,13 +429,12 @@ label _save_reload_game:
         renpy.utter_restart()
 
 label _load_reload_game:
-
-    if not persistent._reload_save:
-        return
+    
+    if not renpy.can_load("_reload-1"):
+        return 
 
     python hide:
-        save = persistent._reload_save
-        persistent._reload_save = 0
+        renpy.rename_save("_reload-1", "_reload-2")
 
         ui.add(Solid((0, 0, 0, 255)))
         ui.text("Reloading game...",
@@ -347,7 +443,7 @@ label _load_reload_game:
         ui.pausebehavior(0)
         ui.interact(suppress_underlay=True, suppress_overlay=True)
         
-        renpy.load(save)
+        renpy.load("_reload-2")
 
     return
 
@@ -370,6 +466,17 @@ init 1180 python:
         if config.default_text_cps is not None:
             _preferences.text_cps = config.default_text_cps
 
+        if config.default_afm_time is not None:
+            _preferences.afm_time = config.default_afm_time
+            
+    if config.default_afm_enable is not None:
+        _preferences.afm_enable = config.default_afm_enable
+        _preferences.using_afm_enable = True
+    else:
+        _preferences.afm_enable = True
+        _preferences.using_afm_enable = False
+    
+
     if config.developer:
 
         def _inspector(l):
@@ -381,7 +488,6 @@ init 1180 python:
             ui.text("Style Inspector")
             ui.text("")
 
-
             if not l:
                 ui.text("Nothing to inspect.")
             
@@ -508,18 +614,23 @@ init 1180 python:
             
 label _enter_menu:
     python hide:
-        renpy.movie_stop()
+        renpy.movie_stop(only_fullscreen=True)
         renpy.take_screenshot((config.thumbnail_width, config.thumbnail_height))
 
+        for i in config.menu_clear_layers:
+            renpy.scene(layer=i)
+        
         renpy.context()._menu = True
         
         # This may be changed, if we are already in the main menu.
-        renpy.context().main_menu = False
+        renpy.context()._main_menu = False
         renpy.context_dynamic("main_menu")
         renpy.context_dynamic("_window_subtitle")
-
+        renpy.context_dynamic("_window")
+        
         store.main_menu = False
         store._window_subtitle = config.menu_window_subtitle
+        store._window = False
         
         store.mouse_visible = True
         store.suppress_overlay = True
@@ -552,9 +663,14 @@ label _game_menu(_game_menu_screen=_game_menu_screen):
     $ 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"
+
+    if renpy.has_screen(_game_menu_screen):
+        $ renpy.show_screen(_game_menu_screen)
+        $ ui.interact()
+        jump _noisy_return
         
     jump expression _game_menu_screen
 
@@ -596,16 +712,15 @@ label _noisy_return:
 # Return to the game.
 label _return:
 
-    if renpy.context().main_menu:
+    if renpy.context()._main_menu:
         $ renpy.transition(config.game_main_transition)
-        jump _main_menu
+        jump _main_menu_screen
 
     $ renpy.transition(config.exit_transition)
 
     return
 
 label _confirm_quit:
-    call _enter_menu from _call__enter_menu_3
 
     if renpy.has_label("confirm_quit"):
         jump expression "confirm_quit"
@@ -631,6 +746,7 @@ init -1180 python hide:
 # after_load.
 label _after_load:
     $ renpy.context()._menu = False
+    $ renpy.context()._main_menu = False
 
     if config.after_load_transition:
         $ renpy.transition(config.after_load_transition, force=True)
@@ -647,15 +763,25 @@ label _start:
 
     python hide:
         renpy.context()._menu = False
+        renpy.context()._main_menu = False
         
         for i in config.start_callbacks:
             i()
-    
-    call _check_module from _call__check_module_1
+
+    $ renpy.block_rollback()
+
+    call _gl_test
+            
     call _load_reload_game from _call__load_reload_game_1
 
-    scene black
+    if not _restart and config.auto_load and renpy.can_load(config.auto_load):
+        $ renpy.load(config.auto_load)
 
+    if config.start_scene_black:        
+        scene black
+    else:
+        scene
+        
     if not _restart:
         $ ui.pausebehavior(0)
         $ ui.interact(suppress_underlay=True, suppress_overlay=True)
@@ -663,7 +789,9 @@ label _start:
     $ renpy.block_rollback()
 
     $ _old_game_menu_screen = _game_menu_screen
+    $ _old_predict_screens = _predict_screens
     $ _game_menu_screen = None
+    $ _predict_screens = [ 'main_menu' ]
     
     if renpy.has_label("splashscreen") and not _restart:
         call expression "splashscreen" from _call_splashscreen_1
@@ -673,36 +801,43 @@ label _start:
         
     $ 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)
+    if config.start_scene_black:
+        scene black
     else:
-        $ renpy.transition(_restart[0])
-        jump expression _restart[1]
+        scene
+
+
+    # This has to be python, to deal with a case where _restart may
+    # change across a shift-reload.
+    python:
+        if _restart is None:
+            renpy.transition(config.end_splash_transition)
+        else:
+            renpy.transition(_restart[0])
+            renpy.jump(_restart[1])
         
 label _invoke_main_menu:
-        
-    $ renpy.call_in_new_context("_enter_main_menu")
 
+    # Again, this has to be python.
+    python:
+        if _restart:
+            renpy.call_in_new_context(_restart[2])
+        else:
+            renpy.call_in_new_context("_main_menu")
+        
+        
     # If the main menu returns, then start the game.
     jump start
 
 # At this point, we've been switched into a new context. So we
 # initialize it.
-label _enter_main_menu:
+label _main_menu(_main_menu_screen="_main_menu_screen"):
 
     call _enter_menu from _call__enter_menu_1
 
@@ -710,11 +845,13 @@ label _enter_main_menu:
         renpy.dynamic("_load_prompt")
         _load_prompt = False
 
-        renpy.context().main_menu = True
+        renpy.context()._main_menu = True
         store.main_menu = True
+
+    jump expression _main_menu_screen
         
 # This is called to show the main menu to the user.
-label _main_menu:    
+label _main_menu_screen:    
 
     # Let the user completely override the main menu. (But please note
     # it still lives in the menu context, rather than the game context.)
@@ -722,11 +859,77 @@ label _main_menu:
         jump expression "main_menu"
 
     # New name.
-    if renpy.has_label("main_menu_screen"):
+    elif renpy.has_label("main_menu_screen"):
         jump expression "main_menu_screen"
 
     # Compatibility name.
-    if renpy.has_label("_library_main_menu"):
+    elif renpy.has_label("_library_main_menu"):
         jump expression "_library_main_menu"
         
     return
+
+init 1180 python hide:
+    
+    def create_automatic_images():
+    
+        seps = config.automatic_images
+
+        if seps is True:
+            seps = [ ' ', '/', '_' ]
+            
+        for dir, fn in renpy.loader.listdirfiles():
+
+            if fn.startswith("_"):
+                continue
+
+            # Only .png and .jpg
+            if not fn.lower().endswith(".png") and not fn.lower().endswith(".jpg"):
+                continue
+
+            # Strip the extension, replace slashes.
+            shortfn = fn[:-4].replace("\\", "/")
+            
+            # Determine the name.
+            name = ( shortfn, )
+            for sep in seps:
+                name = tuple(j for i in name for j in i.split(sep))
+
+            # Strip name components.
+            while name:
+                for i in config.automatic_images_strip:
+                    if name[0] == i:
+                        name = name[1:]
+                        break
+                else:
+                    break
+                
+            # Only names of 2 components or more.
+            if len(name) < 2:
+                continue
+            
+            # Reject if it already exists.
+            if name in renpy.exports.images:
+                continue
+
+            renpy.image(name, fn)
+
+    if config.automatic_images:
+        create_automatic_images()
+
+
+# Load the developer screen, if necessary.
+init 1180 python hide:
+
+    if config.developer:
+        renpy.load_module("_developer")
+
+# Entry point for the developer screen. The rest of it is loaded from
+# _developer.rpym
+label _developer:
+
+    if not config.developer:
+        return
+
+    call _enter_menu from _call__enter_menu_4
+
+    jump expression "_developer_screen"

common/00menus.rpy

@@ -1,7 +1,5 @@
-# Copyright 2008 PyTom
-#
-# Please see the LICENSE.txt distributed with Ren'Py for permission to
-# copy and modify.
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
 
 # Common stuff that's used by the various Ren'Py menus. This includes
 # the default definitions of config.main_menu and config.game_menu, as
@@ -29,13 +27,17 @@ init -1150 python:
         ]
 
 label _quit_prompt:
-    if layout.yesno_prompt(None, u"Are you sure you want to quit?"):
+    $ renpy.loadsave.force_autosave()
+
+    if layout.yesno_prompt(None, layout.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.loadsave.force_autosave()
+
+    if layout.yesno_prompt(None, layout.MAIN_MENU):
         $ renpy.full_restart(transition=config.game_main_transition)
     else:
         return

common/00mixers.rpy

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

common/00nvl_mode.rpy

@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 # This is an implementation of NVL-mode, which can be used to show
 # dialogue in a fullscreen way, like NVL-style games. Multiple lines
 # of dialogue are shown on the screen at once, whenever a line of
@@ -76,9 +79,57 @@ init -1100 python:
             return s[nvl_variant]
         else:
             return s
-    
-    def nvl_show_core():
 
+    def __nvl_screen_dialogue():
+        """
+         Returns widget_properties and dialogue for the current NVL
+         mode screen.
+         """
+
+        widget_properties = { }
+        dialogue = [ ]
+        
+        for i, entry in enumerate(nvl_list):
+            if not entry:
+                continue
+
+            who, what, kwargs = entry
+
+            if i == len(nvl_list) - 1:
+                who_id = "who"
+                what_id = "what"
+                window_id = "window"
+
+            else:
+                who_id = "who%d" % i
+                what_id = "what%d" % i
+                window_id = "window%d" % i
+                
+            widget_properties[who_id] = kwargs["who_args"]
+            widget_properties[what_id] = kwargs["what_args"]
+            widget_properties[window_id] = kwargs["window_args"]
+
+            dialogue.append((who, what, who_id, what_id, window_id))
+        
+        return widget_properties, dialogue
+        
+    def __nvl_show_screen(screen_name, **scope):
+        """
+         Shows an nvl-mode screen. Returns the "what" widget.
+         """
+
+        widget_properties, dialogue = __nvl_screen_dialogue()        
+        renpy.show_screen(screen_name, _transient=True, _widget_properties=widget_properties, dialogue=dialogue, **scope) 
+        renpy.shown_window()
+
+        return renpy.get_widget(screen_name, "what")
+        
+    def nvl_show_core(who=None, what=None):
+
+        # Screen version.
+        if renpy.has_screen("nvl"):
+            return __nvl_show_screen("nvl", items=[ ])
+        
         if renpy.in_rollback():
             nvl_window = __s(style.nvl_window)['rollback']
             nvl_vbox = __s(style.nvl_vbox)['rollback']
@@ -99,8 +150,14 @@ init -1100 python:
             rv = config.nvl_show_display_say(who, what, variant=nvl_variant, **kw)
 
         ui.close()
+
+        renpy.shown_window()
+        
         return rv
 
+    def nvl_window():
+        nvl_show_core()
+    
     def nvl_show(with_):
         nvl_show_core()
         renpy.with_statement(with_)
@@ -185,16 +242,19 @@ init -1100 python:
             else:
                 checkpoint = True
                 
-            renpy.display_say(nvl_show_core,
-                              checkpoint=checkpoint,
-                              **display_args)
+            renpy.display_say(
+                who,
+                what,
+                nvl_show_core,
+                checkpoint=checkpoint,
+                **display_args)
             
         def do_done(self, who, what):
-            
             if self.clear:
                 nvl_clear()
 
         def do_extend(self):
+            renpy.mode(self.mode)
             store.nvl_list = store.nvl_list[:-1]
                 
     # The default NVLCharacter.
@@ -204,21 +264,54 @@ init -1100 python:
         what_style='nvl_dialogue',
         window_style='nvl_entry',
         type='nvl',
+        mode='nvl',
         clear=False,
         kind=adv)
                 
     def nvl_clear():
-
         store.nvl_list = [ ]
 
     # Run clear at the start of the game.
     config.start_callbacks.append(nvl_clear)
-
+    
+    
     def nvl_menu(items):
 
+        renpy.mode('nvl_menu')
+        
         if nvl_list is None:
             store.nvl_list = [ ]
 
+        screen = None
+        
+        if renpy.has_screen("nvl_choice"):
+            screen = "nvl_choice"
+        elif renpy.has_screen("nvl"):
+            screen = "nvl"
+            
+        if screen is not None:
+
+            widget_properties, dialogue = __nvl_screen_dialogue()        
+
+            return renpy.display_menu(
+                items,
+                widget_properties=widget_properties,
+                screen=screen,
+                scope={ "dialogue" : dialogue },
+                window_style=__s(style.nvl_menu_window),
+                choice_style=__s(style.nvl_menu_choice),
+                choice_chosen_style=__s(style.nvl_menu_choice_chosen),
+                choice_button_style=__s(style.nvl_menu_choice_button),
+                choice_chosen_button_style=__s(style.nvl_menu_choice_chosen_button),
+                type="nvl",                      
+                )
+
+
+        # Traditional version.
+        ui.layer("transient")
+        ui.clear()
+        ui.close()
+
         ui.window(style=__s(style.nvl_window))
         ui.vbox(style=__s(style.nvl_vbox))
 
@@ -246,32 +339,28 @@ init -1100 python:
 
         return rv
 
+    NVLSpeaker = NVLCharacter
+    
     config.nvl_adv_transition = None
     config.adv_nvl_transition = None
 
-init 1140 python:
 
-    if config.nvl_adv_transition or config.adv_nvl_transition:
+    # This is used to execute the nvl and adv mode transitions.
+    def _nvl_adv_callback(mode, old_modes):
 
-        def _nvl_adv_callback(event, interact, type, **kwargs):
-        
-            if event != "begin" or not interact or renpy.get_transition():
-                return 
-            
-            old_type = renpy.last_interact_type()
-
-            if old_type == "say" and type == "nvl":
-                # We have an extra line in the nvl_list as we do this. So
-                # take it out for the duration of the nvl_show.
-                old_nvl_list = store.nvl_list
-                store.nvl_list = old_nvl_list[:-1]
-                nvl_show(config.adv_nvl_transition)
-                store.nvl_list = old_nvl_list
-            elif old_type == "nvl" and type == "say":
-                nvl_hide(config.nvl_adv_transition)
-
-        config.all_character_callbacks.insert(0, _nvl_adv_callback)
+        old = old_modes[0]
 
+        if config.adv_nvl_transition:
+            if mode == "nvl" or mode == "nvl_menu":
+                if old == "say" or old == "menu":
+                    nvl_show(config.adv_nvl_transition)
+                    
+        if config.nvl_adv_transition:
+            if mode == "say" or mode == "menu":
+                if old == "nvl" or old == "nvl_menu":
+                    nvl_hide(config.nvl_adv_transition)
+                    
+    config.mode_callbacks.append(_nvl_adv_callback)
     
 python early hide:
 

common/00splines.rpy

@@ -63,15 +63,19 @@ init -1080 python:
    
         def init_values(self, sizes):
             def to_abs_(value, size):
-                if isinstance(value, float):
+                if type(value) ==  float:
                     return value * size
                 else:
                     return value
      
             def coord_(c):
+
+                if len(c) == 2:
+                    c = c + (0, 0)
+
                 return ( to_abs_(c[0], sizes[0]) - to_abs_(c[2], sizes[2]),
                          to_abs_(c[1], sizes[1]) - to_abs_(c[3], sizes[3]) )
-     
+
             for p in self.points:
                 for i in range(1, len(p)):
                     p[i] = coord_(p[i])
@@ -122,8 +126,8 @@ init -1080 python:
                 t3 = t**3
          
                 result = [ t_ppp * start[i] + t_pp * self.points[segment][2][i] + t_p * self.points[segment][3][i] + t3 * end[i] for i in 0,1 ]
-     
-            return ( int(result[0]), int(result[1]), 0, 0 )
+
+            return ( absolute(result[0]), absolute(result[1]), 0, 0 )
 
     def SplineMotion(points, time, child=None, anchors=(0.5, 0.5), repeat=False, bounce=False, anim_timebase=False, style='default', time_warp=None, **properties):
         return Motion(_SplineInterpolator(points, anchors), time, child, repeat=repeat, bounce=bounce, anim_timebase=anim_timebase, style=style, time_warp=time_warp, add_sizes=True, **properties)

common/00statements.rpy

@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 # This file contains code that creates a few new statements. We'll
 # also describe here the API for defining your own statements.
 #
@@ -67,6 +70,8 @@ python early hide:
         fadeout = "None"
         fadein = "0"
         channel = None
+        loop = None
+        if_changed = False
         
         while True:
 
@@ -93,42 +98,63 @@ python early hide:
                     renpy.error('expected simple expression')
 
                 continue
-                    
+
+            if l.keyword('loop'):
+                loop = True
+                continue
+                
+            if l.keyword('noloop'):
+                loop = False
+                continue
+
+            if l.keyword('if_changed'):
+                if_changed = True
+                continue
+            
             renpy.error('could not parse statement.')
 
         return dict(file=file,
                     fadeout=fadeout,
                     fadein=fadein,
-                    channel=channel)
+                    channel=channel,
+                    loop=loop,
+                    if_changed=if_changed)
 
     def execute_play_music(p):
 
         if p["channel"] is not None:
             channel = eval(p["channel"])
         else:
-            channel = 7
+            channel = "music"
         
         renpy.music.play(eval(p["file"]),
                          fadeout=eval(p["fadeout"]),
                          fadein=eval(p["fadein"]),
-                         channel=channel)
+                         channel=channel,
+                         loop=p.get("loop", None),
+                         if_changed=p.get("if_changed", False))
 
     def predict_play_music(p):
         return [ ]
 
-    def lint_play_music(p):
+    def lint_play_music(p, channel="music"):
 
         file = _try_eval(p["file"], 'filename')
-        if p["channel"] is not None:
-            _try_eval(p["channel"], 'channel')
 
+        if p["channel"] is not None:
+            channel = _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)
-    
+            if isinstance(fn, basestring):
+                try:
+                    if not renpy.music.playable(fn, channel):
+                        renpy.error("%r is not loadable" % fn)
+                except:
+                    pass
+                        
     renpy.statements.register('play music',
                               parse=parse_play_music,
                               execute=execute_play_music,
@@ -145,24 +171,37 @@ python early hide:
             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')
+        loop = None
+        
+        while not l.eol():
+        
+            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 l.keyword('loop'):
+                loop = True
+                continue
+                
+            if l.keyword('noloop'):
+                loop = False
+                continue
 
-        return dict(file=file, channel=channel)
+            renpy.error('expected end of line')
+
+        return dict(file=file, channel=channel, loop=loop)
 
     def execute_queue_music(p):
         if p["channel"] is not None:
             channel = eval(p["channel"])
         else:
-            channel = 7
+            channel = "music"
         
-        renpy.music.queue(eval(p["file"]), channel=channel)
+        renpy.music.queue(
+            eval(p["file"]),
+            channel=channel,
+            loop=p.get("loop", None))
 
 
     renpy.statements.register('queue music',
@@ -195,7 +234,7 @@ python early hide:
         if p["channel"] is not None:
             channel = eval(p["channel"])
         else:
-            channel = 7
+            channel = "music"
         
         renpy.music.stop(fadeout=eval(p["fadeout"]), channel=channel)
 
@@ -212,7 +251,7 @@ python early hide:
         if p["channel"] is not None:
             channel = eval(p["channel"])
         else:
-            channel = 0
+            channel = "sound"
 
         fadeout = eval(p["fadeout"]) or 0
             
@@ -220,17 +259,20 @@ python early hide:
                          fadeout=fadeout,
                          fadein=eval(p["fadein"]),
                          channel=channel)
-                       
+
+    def lint_play_sound(p, lint_play_music=lint_play_music):
+        return lint_play_music(p, channel="sound")
+        
     renpy.statements.register('play sound',
                               parse=parse_play_music,
                               execute=execute_play_sound,
-                              lint=lint_play_music)
+                              lint=lint_play_sound)
 
     def execute_queue_sound(p):
         if p["channel"] is not None:
             channel = eval(p["channel"])
         else:
-            channel = 0
+            channel = "sound"
 
         renpy.sound.queue(eval(p["file"]), channel=channel)
 
@@ -244,7 +286,7 @@ python early hide:
         if p["channel"] is not None:
             channel = eval(p["channel"])
         else:
-            channel = 0
+            channel = "sound"
 
         fadeout = eval(p["fadeout"]) or 0
 
@@ -254,13 +296,266 @@ python early hide:
                               parse=parse_stop_music,
                               execute=execute_stop_sound)
 
+
+    # Generic play/queue/stop statements. These take a channel name as
+    # the second thing.
+
+    def parse_play_generic(l, parse_play_music=parse_play_music):
+        channel = l.name()
+
+        if channel is None:
+            renpy.error('play requires a channel')
+
+        rv = parse_play_music(l)
+        if rv["channel"] is None:
+            rv["channel"] = repr(channel)
+
+        return rv
+
+    def parse_queue_generic(l, parse_queue_music=parse_queue_music):
+        channel = l.name()
+
+        if channel is None:
+            renpy.error('queue requires a channel')
+
+        rv = parse_queue_music(l)
+        if rv["channel"] is None:
+            rv["channel"] = repr(channel)
+
+        return rv
+
+    def parse_stop_generic(l, parse_stop_music=parse_stop_music):
+        channel = l.name()
+
+        if channel is None:
+            renpy.error('stop requires a channel')
+
+        rv = parse_stop_music(l)
+        if rv["channel"] is None:
+            rv["channel"] = repr(channel)
+
+        return rv
+
+    def lint_play_generic(p, lint_play_music=lint_play_music):
+        channel = eval(p["channel"])
+        
+        if not renpy.music.channel_defined(channel):
+            renpy.error("channel %r is not defined" % channel)
+
+        lint_play_music(p, channel)
+
+    def lint_stop_generic(p):
+        channel = eval(p["channel"])
+        
+        if not renpy.music.channel_defined(channel):
+            renpy.error("channel %r is not defined" % channel)
+
+    renpy.statements.register('play',
+                              parse=parse_play_generic,
+                              execute=execute_play_music,
+                              predict=predict_play_music,
+                              lint=lint_play_generic)
+    
+    renpy.statements.register('queue',
+                              parse=parse_queue_generic,
+                              execute=execute_queue_music,
+                              lint=lint_play_generic)
+            
+    renpy.statements.register('stop',
+                              parse=parse_stop_generic,
+                              execute=execute_stop_music,
+                              lint=lint_stop_generic)
+
+
+    ##########################################################################
+    # "window show" and "window hide" statements.
+
+    def parse_window(l):
+        p = l.simple_expression()
+        if not l.eol():
+            renpy.error('expected end of line')
+
+        return p
+            
+    def lint_window(p):
+        if p is not None:
+            _try_eval(p, 'window transition')
+
+    def execute_window_show(p):
+        if store._window:
+            return
+
+        if p is not None:
+            trans = eval(p)
+        else:
+            trans = config.window_show_transition
+            
+        renpy.with_statement(None)
+        store._window = True
+        renpy.with_statement(trans)
+        
+    def execute_window_hide(p):
+        if not _window:
+            return
+        
+        if p is not None:
+            trans = eval(p)
+        else:
+            trans = config.window_hide_transition
+
+        renpy.with_statement(None)
+        store._window = False
+        renpy.with_statement(trans)
+
+    renpy.statements.register('window show',
+                              parse=parse_window,
+                              execute=execute_window_show,
+                              lint=lint_window)
+
+    renpy.statements.register('window hide',
+                              parse=parse_window,
+                              execute=execute_window_hide,
+                              lint=lint_window)
+
+    ##########################################################################
+    # Pause statement.
+    
+    def parse_pause(l):
+
+        delay = l.simple_expression()
+
+        if not l.eol():
+            renpy.error("expected end of line.")
+
+        return { "delay" : delay }
+
+    def lint_pause(p):
+
+        if p["delay"]:
+            _try_eval(p["delay"], 'pause statement')
+            
+    def execute_pause(p):
+
+        if p["delay"]:
+            delay = eval(p["delay"])
+            renpy.with_statement(Pause(delay))
+        else:
+            renpy.pause()
+
+
+    renpy.statements.register('pause',
+                              parse=parse_pause,
+                              lint=lint_pause,
+                              execute=execute_pause)
     
                               
 init -1200 python:
 
+    config.window_show_transition = None
+    config.window_hide_transition = None
+    
     def _try_eval(e, what):
         try:
             return eval(e)
         except:
             renpy.error('unable to evaluate %s %r' % (what, e))
     
+##############################################################################
+# Screen-related statements.
+
+python early hide:
+
+    def parse_show_call_screen(l):
+
+        # Parse a name.
+        name = l.require(l.name)
+
+        # Parse a parameter list. (name -> expression string)
+        parameters = { }
+        
+        if l.match(r"\("):
+
+            while True:
+                pname = l.name()
+                if not pname:
+                    break
+
+                l.require(r"=")
+
+                expr = l.delimited_python(",)")
+
+                if not expr:
+                    l.error("expected expression.")
+
+                parameters[pname] = expr
+
+                if not l.match(r','):
+                    break
+
+            l.require(r'\)')
+            l.expect_eol()
+            
+        return dict(name=name, parameters=parameters)
+
+    def parse_hide_screen(l):
+        name = l.require(l.name)
+
+        l.expect_eol()
+
+        return dict(name=name)
+
+    def predict_screen(p):
+        if not p["parameters"]:
+            renpy.predict_screen(p["name"])
+    
+    def execute_show_screen(p):
+
+        name = p["name"]
+        parameters = p["parameters"]
+
+        kwargs = { }
+
+        for k, v in parameters.iteritems():
+            kwargs[k] = eval(v)
+
+        renpy.show_screen(name, **kwargs)
+
+    def execute_call_screen(p):
+        name = p["name"]
+        parameters = p["parameters"]
+
+        kwargs = { }
+
+        for k, v in parameters.iteritems():
+            kwargs[str(k)] = eval(v)
+
+        store._return = renpy.call_screen(name, **kwargs)
+
+    def execute_hide_screen(p):
+        name = p["name"]
+        renpy.hide_screen(name)
+        
+    def lint_screen(p):
+        name = p["name"]
+        if not renpy.has_screen(name):
+            renpy.error("Screen %s does not exist." % name)
+
+        
+    renpy.statements.register("show screen",
+                              parse=parse_show_call_screen,
+                              execute=execute_show_screen,
+                              predict=predict_screen,
+                              lint=lint_screen)
+
+    renpy.statements.register("call screen",
+                              parse=parse_show_call_screen,
+                              execute=execute_call_screen,
+                              predict=predict_screen,
+                              lint=lint_screen)
+
+    renpy.statements.register("hide screen",
+                              parse=parse_hide_screen,
+                              execute=execute_hide_screen)
+
+            
+    

common/00style.rpy

@@ -1,7 +1,5 @@
-# Copyright 2004-2008 PyTom
-#
-# Please see the LICENSE.txt distributed with Ren'Py for permission to
-# copy and modify.
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
 
 # This file is responsible for creating and defining the default styles
 # used by the system.
@@ -24,15 +22,20 @@ init -1200 python hide:
     # Style Declarations #################################################
 
     style.default = Style(None, help='root of style hierarchy')
+    style.text = Style(style.default, help='style of text')
 
+    style.fixed = Style(style.default, help='fixed layouts')
     style.hbox = Style(style.default, help='horizontal boxes')
     style.vbox = Style(style.default, help='vertical boxes')
-
+    style.grid = Style(style.default, help='grid layouts')
+    style.side = Style(style.default, help='side layouts')
+    
     style.window = Style(style.default, help='windows created with ui.window')
 
     style.image_placement = Style(style.default, help='default placement of images on the screen')
     style.image = Style(style.default, help="default style of images")
 
+    style.motion = Style(style.default, help="default style of motions and zooms.")
     style.animation = Style(style.default, help="default style of animations.")
 
     style.say_label = Style(style.default, help='the name of the character speaking dialogue.')
@@ -51,7 +54,8 @@ init -1200 python hide:
     style.menu_choice_chosen_button = Style(style.menu_choice_button, help='buttons containing chosen in-game menu choices')
     style.menu_window = Style(style.window, help='a window containing a menu')
 
-    style.input_text = Style(style.default, help='text of an input box')
+    style.input = Style(style.default, help='style of an input control')
+    style.input_text = Style(style.input, help='text of an input box')
     style.input_prompt = Style(style.default, help='prompt of an input box')
     style.input_window = Style(style.window, help='window of an input box')
 
@@ -59,8 +63,10 @@ init -1200 python hide:
     style.centered_text = Style(style.default, help='centered text')
 
     style.imagemap = Style(style.image_placement, help='default style of imagemaps')
-    style.imagemap_button = Style(style.default, help='default style of buttons inside imagemaps')
-
+    style.hotspot = Style(style.default, help='default style of hotspots inside imagemaps')
+    style.hotbar = Style(style.default, help='default style of hotbars inside imagemaps')
+    style.imagemap_button = style.hotspot
+    
     style.image_button = Style(style.default, help='default style of image buttons')
     style.image_button_image = Style(style.default, help='default style of images inside image buttons')
 
@@ -68,6 +74,7 @@ init -1200 python hide:
     style.hyperlink_text = Style(style.default, help='hyperlinked text')
 
     style.viewport = Style(style.default, help='default style of viewports')
+    style.transform = Style(style.motion, help='default style of transforms')
     
     style.list = Style(style.default)
     style.list_box = Style(style.vbox)
@@ -76,6 +83,8 @@ init -1200 python hide:
     style.list_spacer = Style(style.default)    
     style.list_text = Style(style.default)
 
+    style.tile = Style(style.default, help='default style of tile')
+    
 # The base styles that can be customized by themes.
 
     style.frame = Style(style.default, help='base style for frames.')
@@ -166,7 +175,8 @@ init -1090 python:
     style.default.ymaximum = None
     style.default.xoffset = 0
     style.default.yoffset = 0
-
+    style.default.subpixel = False
+    
     # Sound properties.
     style.default.sound = None
 
@@ -197,6 +207,12 @@ init -1090 python:
     style.hbox.box_layout = 'horizontal'
     style.vbox.box_layout = 'vertical'
 
+    # Motions, zooms, rotozooms, and transforms.
+    style.motion.xanchor = 0
+    style.motion.yanchor = 0
+    style.motion.xpos = 0
+    style.motion.ypos = 0
+    
     # Windows.
     style.window.background = Solid((0, 0, 0, 192))
     style.window.xpadding = 6
@@ -206,16 +222,9 @@ init -1090 python:
     style.window.xfill = True
     style.window.yfill = False
     style.window.yminimum = 150 # Includes margins and padding.
-
     style.window.xalign = 0.5
     style.window.yalign = 1.0
 
-    # Image placement.
-    style.image_placement.xpos = 0.5
-    style.image_placement.ypos = 1.0
-    style.image_placement.xanchor = 0.5
-    style.image_placement.yanchor = 1.0
-
     # Dialogue
     style.say_label.bold = True
     style.say_vbox.spacing = 8
@@ -231,7 +240,7 @@ init -1090 python:
     # Menus.
     style.menu_choice.idle_color = "#0ff"
     style.menu_choice.hover_color = "#ff0"
-    style.input_text.color = "#ff0"
+    style.input.color = "#ff0"
 
     # Styles used by centered.
     style.centered_window.xalign = 0.5
@@ -263,6 +272,9 @@ init -1090 python:
     # Viewport
     style.viewport.clipping = True
 
+    # Transform
+    style.transform.subpixel = True
+    
     # Menu windows.
     style.mm_root.background = "#000"
     style.mm_root.xfill = True
@@ -285,7 +297,10 @@ init -1090 python:
     style.list_text.color = "#000"
     style.list_text.size = 14
     style.list_spacer.xminimum = 15
-       
+
+    # Tile
+    style.tile.clipping = True
+    
     
     ######################################################################
 

common/00themes.rpy

@@ -1,7 +1,5 @@
-# Copyright 2004-2008 PyTom
-#
-# Please see the LICENSE.txt distributed with Ren'Py for permission to
-# copy and modify.
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
 
 init -1110 python:
 
@@ -73,9 +71,7 @@ init -1110 python hide:
         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):
@@ -84,300 +80,329 @@ init -1110 python hide:
         else:
             return im.Twocolor(image, color, color)
 
-    @theme
-    def roundrect_frames(
-        less_rounded,
-        frame):
+    def roundrect_based_theme(name, file_prefix, Box=None, frame_png=None):
 
-        theme.clear_frames()
-        
-        style.frame.background = RoundRect(frame, less_rounded)
+        if Box is None:
+            def Box(color, ignored):
+                return Frame(theme.OneOrTwoColor(file_prefix + "_box.png", color), 12, 12)
 
-        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
+        if frame_png is not None:
+            def FrameBox(color, ignored):
+                return Frame(theme.OneOrTwoColor(file_prefix + frame_png, color), 12, 12)
         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
+            FrameBox = Box
             
-        else:
-            text_size = text_size or 22
-            small_text_size = small_text_size or 16
-            radius = 12
-
-        theme.roundrect_frames(
+        def frames(
             less_rounded,
-            frame)
+            frame):
 
-        theme.roundrect_buttons(
-            text_size,
-            less_rounded,
-            widget,
-            widget_hover,
-            widget_text,
-            widget_selected,
-            disabled,
-            disabled_text)
+            theme.clear_frames()
 
-        theme.roundrect_large_buttons(
-            small_text_size,
-            less_rounded,
-            widget,
-            widget_hover,
-            widget_text,
-            widget_selected,
-            disabled,
-            disabled_text)
+            style.frame.background = Box(frame, less_rounded)
 
-        theme.roundrect_labels(
-            text_size,
-            label)
+            style.frame.xpadding = 6
+            style.frame.ypadding = 6
+        
+        setattr(theme, name + "_frames", frames)
 
-        theme.roundrect_prompts(
-            text_size,
-            label)
-
-        theme.roundrect_bars(
-            widget,
-            widget_hover)
             
-        if mm_root is not None:
-            style.mm_root.background = mm_root
+        def buttons(text_size,
+                    less_rounded,
+                    widget,
+                    widget_hover,
+                    widget_text,
+                    widget_selected,
+                    disabled,
+                    disabled_text):
 
-        if gm_root is not None:
-            style.gm_root.background = gm_root
-            
-        if window is not None:
+            theme.clear_buttons()
 
-            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
+            style.button.background = Box(widget, less_rounded)
+            style.button.hover_background = Box(widget_hover, less_rounded)
+            style.button.insensitive_background = Box(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.window.background = Solid(window)
-                style.window.xpadding = 6
-                style.window.xmargin = 0
-                style.window.ypadding = 6
-                style.window.ymargin = 0
+                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
+
+        setattr(theme, name + "_buttons", buttons)
+            
+        def 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 = Box(widget, less_rounded)
+            style.large_button.hover_background = Box(widget_hover, less_rounded)
+            style.large_button.insensitive_background = Box(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
+
+        setattr(theme, name + "_large_buttons", large_buttons)
+            
+        def labels(
+            text_size,
+            label):
+
+            theme.clear_labels()
+
+            style.label_text.size = text_size
+            style.label_text.color = label
+
+        setattr(theme, name + "_labels", labels)
+            
+        def 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"
+ 
+        setattr(theme, name + "_prompts", prompts)
+       
+            
+        def bars(
+            widget,
+            widget_hover):
+
+            theme.clear_bars()
+
+            def img(name, color, x, y):
+                rv = theme.OneOrTwoColor(file_prefix + name + ".png", color)
+                if x is not None:
+                    rv = Frame(rv, x, y, tile=True)
+                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("slider_full", widget, 12, 0)
+            style.bar.right_bar = img("slider_empty", widget, 12, 0)
+            style.bar.thumb = img("slider_thumb", widget, None, None)
+            style.bar.hover_left_bar = img("slider_full", widget_hover, 12, 0)
+            style.bar.hover_right_bar = img("slider_empty", widget_hover, 12, 0)
+            style.bar.hover_thumb = img("slider_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("vslider_full", widget, 0, 12)
+            style.vbar.top_bar = img("vslider_empty", widget, 0, 12)
+            style.vbar.thumb = img("vslider_thumb", widget, None, None)
+            style.vbar.hover_bottom_bar = img("vslider_full", widget_hover, 0, 12)
+            style.vbar.hover_top_bar = img("vslider_empty", widget_hover, 0, 12)
+            style.vbar.hover_thumb = img("vslider_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("slider_full", widget, 12, 0)
+            style.slider.right_bar = img("slider_empty", widget, 12, 0)
+            style.slider.thumb = img("slider_thumb", widget, None, None)
+            style.slider.hover_left_bar = img("slider_full", widget_hover, 12, 0)
+            style.slider.hover_right_bar = img("slider_empty", widget_hover, 12, 0)
+            style.slider.hover_thumb = img("slider_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("vslider_full", widget, 0, 12)
+            style.vslider.top_bar = img("vslider_empty", widget, 0, 12)
+            style.vslider.thumb = img("vslider_thumb", widget, None, None)
+            style.vslider.hover_bottom_bar = img("vslider_full", widget_hover, 0, 12)
+            style.vslider.hover_top_bar = img("vslider_empty", widget_hover, 0, 12)
+            style.vslider.hover_thumb = img("vslider_thumb", widget_hover, None, None)
 
 
-        if button_menu:
-            layout.button_menu()
+            # 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("scrollbar", widget, 12, 0)
+            style.scrollbar.right_bar = img("scrollbar", widget, 12, 0)
+            style.scrollbar.thumb = img("scrollbar_thumb", widget, None, None)
+            style.scrollbar.hover_left_bar = img("scrollbar", widget_hover, 12, 0)
+            style.scrollbar.hover_right_bar = img("scrollbar", widget_hover, 12, 0)
+            style.scrollbar.hover_thumb = img("scrollbar_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("vscrollbar", widget, 0, 12)
+            style.vscrollbar.right_bar = img("vscrollbar", widget, 0, 12)
+            style.vscrollbar.thumb = img("vscrollbar_thumb", widget, None, None)
+            style.vscrollbar.hover_left_bar = img("vscrollbar", widget_hover, 0, 12)
+            style.vscrollbar.hover_right_bar = img("vscrollbar", widget_hover, 0, 12)
+            style.vscrollbar.hover_thumb = img("vscrollbar_thumb", widget_hover, None, None)
+
+        setattr(theme, name + "_bars", bars)
+        
+        def main(
+            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),
+
+            text_size=None,
+            small_text_size=None,
+            less_rounded = False,        
+
+            # Compat for the old roundrect theme.
+            window = None,
+            button_menu = None,
+            rounded_window = True,
+            outline_bars = False,
+            mm_root = None,
+            gm_root = None):
+
+            if button_menu is None:
+                if (config.script_version is not None) and (config.script_version < (6, 9, 0)):
+                    button_menu = True
+                else:
+                    button_menu = False
+
+            layout.defaults()
+
+            if config.screen_width <= 640:
+                text_size = text_size or 18
+                small_text_size = small_text_size or 12
+                less_rounded = True
+
+            else:
+                text_size = text_size or 22
+                small_text_size = small_text_size or 16
+                radius = 12
+
+            frames(
+                less_rounded,
+                frame)
+
+            buttons(
+                text_size,
+                less_rounded,
+                widget,
+                widget_hover,
+                widget_text,
+                widget_selected,
+                disabled,
+                disabled_text)
+
+            large_buttons(
+                small_text_size,
+                less_rounded,
+                widget,
+                widget_hover,
+                widget_text,
+                widget_selected,
+                disabled,
+                disabled_text)
+
+            labels(
+                text_size,
+                label)
+
+            prompts(
+                text_size,
+                label)
+
+            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()
+
+        setattr(theme, name, main)
+
+    roundrect_based_theme("roundrect", "_roundrect/rr", RoundRect)
+    roundrect_based_theme("bordered", "_theme_bordered/br")
+    roundrect_based_theme("diamond", "_theme_diamond/d")
+    roundrect_based_theme("tv", "_theme_tv/t")
+    roundrect_based_theme("glow", "_theme_glow/g", None, "_outline.png")
+
+        
     @theme
     def ancient():
 

common/00voice.rpy

@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 # This extra contains a basic implementation of voice support. Right
 # now, voice is given its own toggle, and can either be turned on or
 # turned off. In the future, we'll probably provide some way of
@@ -27,15 +30,17 @@ init -1120:
         _voice.play = None
         _voice.sustain = False
         _voice.seen_in_lint = False
-        
+
         # Call this to specify the voice file that will be played for
         # the user.
         def voice(file, **kwargs):
+
             if not config.has_voice:
                 return
             
             _voice.play = file
-
+            _last_voice_play = file 
+            
         # Call this to specify that the currently playing voice file
         # should be sustained through the current interaction.
         def voice_sustain(ignored="", **kwargs):
@@ -44,6 +49,14 @@ init -1120:
             
             _voice.sustain = True
 
+        # Call this to replay the last bit of voice.
+        def voice_replay():
+            renpy.sound.play(_last_voice_play, channel="voice")
+
+        # Returns true if we can replay the voice.
+        def voice_can_replay():
+            return _last_voice_play != None
+            
     python hide:
 
         # basics: True if the game will have voice.
@@ -52,14 +65,16 @@ init -1120:
         # 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)
+                renpy.sound.play(_voice.play, channel="voice")
+                store._last_voice_play = _voice.play        
             elif not _voice.sustain:
-                renpy.sound.stop(channel=2)
+                renpy.sound.stop(channel="voice")
+                store._last_voice_play = _voice.play        
 
             _voice.play = None
             _voice.sustain = False
@@ -68,7 +83,7 @@ init -1120:
         config.say_sustain_callbacks.append(voice_sustain)
 
         def voice_afm_callback():
-            return not renpy.sound.is_playing(channel=2)
+            return not renpy.sound.is_playing(channel="voice")
 
         config.afm_callback = voice_afm_callback
                        

common/DejaVuSans.txt

@@ -1,4 +1,5 @@
-Fonts are (c) Bitstream (see below). DejaVu changes are in public domain. Glyphs imported from Arev fonts are (c) Tavmjung Bah (see below)
+Fonts are (c) Bitstream (see below). DejaVu changes are in public domain.
+Glyphs imported from Arev fonts are (c) Tavmjong Bah (see below)
 
 Bitstream Vera Fonts Copyright
 ------------------------------
@@ -95,4 +96,4 @@ dealings in this Font Software without prior written authorization
 from Tavmjong Bah. For further information, contact: tavmjong @ free
 . fr.
 
-$Id: LICENSE 778 2006-04-20 18:14:24Z moyogo $
+$Id: LICENSE 2133 2007-11-28 02:46:28Z lechimp $

common/_compat/gamemenu.rpym

@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:
 
     ######################################################################

common/_compat/library.rpym

@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init:
     python:
 

common/_compat/mainmenu.rpym

@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init -1170 python hide:
 
     config.old_names['Quit'] = 'Quit Game'

common/_compat/preferences.rpym

@@ -1,4 +1,7 @@
-# Copyright 2004-2006 PyTom
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# Copyright 2004-2011 Tom Rothamel
 #
 # Please see the LICENSE.txt distributed with Ren'Py for permission to
 # copy and modify.

common/_compat/styles.rpym

@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python hide:
 
     style.menu_button = Style(style.button, heavy=True, help='Buttons that are part of the main or game menus.')

common/_compat/themes.rpym

@@ -1,4 +1,7 @@
-# Copyright 2004-2007 PyTom
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
+# Copyright 2004-2011 Tom Rothamel
 #
 # Please see the LICENSE.txt distributed with Ren'Py for permission to
 # copy and modify.

common/_developer.rpym

@@ -1,32 +1,34 @@
-# Entry point for the developer console.
-label _developer:
+# This file contains code that helps support the development of Ren'Py
+# games.
 
-    if not config.developer:
-        return
+screen _developer:
+    window style "gm_root"
 
-    call _enter_menu from _call__enter_menu_4
+    frame:
+        style_group "_developer"
 
+        align (.025, .05)
+
+        has vbox:
+            first_spacing 10
+
+        label "Developer Menu"
+
+        textbutton _(u"Return") action Return()
+        textbutton _(u"Reload Game (Shift + R)") action ui.callsinnewcontext("_save_reload_game")
+        textbutton _(u"Variable Viewer") action Jump("_debugger_screen")
+        textbutton _(u"Theme Test") action Jump("_theme_test")
+        textbutton _(u"Style Hierarchy") action Jump("_style_hierarchy")
+        textbutton _(u"Image Location Picker") action Jump("_image_location_picker")
+        textbutton _(u"Filename List") action Jump("_filename_list")
+        
+init python hide:
+    style._developer_button = Style(style.button)
+    style._developer_button.size_group = "_developer"
+        
 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()
+    call screen _developer
         
     return 
         
@@ -95,7 +97,7 @@ label _theme_test:
                 return ""
         
         toggle_var = True
-        adj = ui.adjustment(100, 25, page=25)
+        adj = ui.adjustment(100, 25, page=25, adjustable=True)
         
         while True:
 
@@ -196,6 +198,9 @@ label _style_hierarchy:
     jump _developer_screen
     
 
+init -1050 python:
+    config.missing_background = "black"
+    
 init 1050 python:
     
     if renpy.game.options.remote:
@@ -238,7 +243,7 @@ init 1050 python:
 
             global __missing_scene
             if __missing_scene:
-                renpy.show(name, what="black")
+                renpy.show(name, what=config.missing_background)
             __missing_scene = False
                 
             what = " ".join(what).replace("{", "{{")
@@ -284,3 +289,213 @@ init 1050 python:
         config.missing_show = __missing_show_callback
         config.missing_hide = __missing_hide_callback
         config.overlay_functions.append(__missing_overlay)
+
+init -1050 python:
+
+    class __FPSMeter(object):
+
+        def __init__(self):
+            self.last_frames = None
+            self.last_time = None
+
+        def __call__(self, st, at):
+
+            if self.last_time is not None:
+                frames = config.frames - self.last_frames
+                time = st - self.last_time
+
+                text = "FPS: %.1f" % (frames / time)
+
+            else:
+                text = "FPS: --.-"
+
+            self.last_frames = config.frames
+            self.last_time = st
+
+            return Text(text, xalign=1.0), .5
+    
+label _fps_meter:
+
+    python hide:
+        def fps_overlay():
+            ui.add(DynamicDisplayable(__FPSMeter()))
+        
+        # We normally don't want to change this at runtime... but here
+        # it's okay, because we don't want to save the FPS meter anyway.
+        #
+        # Do as I say, not as I do.
+        config.overlay_functions.append(fps_overlay)
+
+    return
+
+init python:
+    
+    # This is a displayable that can keep track of the mouse coordinates,
+    # and show them to the user.
+    class __ImageLocationPicker(renpy.Displayable):
+
+        def __init__(self, fn, **kwargs):
+            super(__ImageLocationPicker, self).__init__(**kwargs)
+            
+            self.child = Image(fn)
+
+            self.mouse = None
+            self.point1 = None
+            self.point2 = None
+            
+        def render(self, width, height, st, at):
+            rv = renpy.Render(width, height)
+
+            cr = renpy.render(self.child, width, height, st, at)
+            rv.blit(cr, (0, 0))
+
+            text = [ ]
+            
+
+            if self.point1 and self.point2 and not self.point1 == self.point2:
+                x1, y1 = self.point1
+                x2, y2 = self.point2
+
+                x1 = min(x1, cr.width)
+                x2 = min(x2, cr.width)
+                y1 = min(y1, cr.height)
+                y2 = min(y2, cr.height)
+                
+                minx = min(x1, x2)
+                miny = min(y1, y2)
+                maxx = max(x1, x2)
+                maxy = max(y1, y2)
+                
+                w = maxx - minx
+                h = maxy - miny
+
+                if w and h:
+
+                    sr = renpy.render(Solid("#0ff4"), w, h, st, at)
+                    rv.blit(sr, (minx, miny))
+
+                    # text.append("Imagemap rectangle: %r" % ((minx, miny, maxx, maxy),))
+                    text.append("Rectangle: %r" % ((minx, miny, w, h),))
+                
+            if self.mouse:
+                mx, my = self.mouse
+                if mx < cr.width and my < cr.height:
+                    text.append(_("Mouse position: %r") % (self.mouse,))
+                    
+            text.append(_("Right-click or escape to quit."))
+                
+            td = Text("\n".join(text), size=14, color="#fff", outlines=[ (1, "#000", 0, 0 ) ])
+            tr = renpy.render(td, width, height, st, at)
+
+            rv.blit(tr, (0, height - tr.height))
+            
+            return rv
+
+        def event(self, ev, x, y, st):
+            import pygame
+
+            self.mouse = (x, y)
+            renpy.redraw(self, 0)
+
+            if ev.type == pygame.MOUSEBUTTONDOWN and ev.button == 1:
+                self.point1 = (x, y)
+                self.point2 = (x, y)
+
+            elif ev.type == pygame.MOUSEMOTION and ev.buttons[0]:
+                self.point2 = (x, y)
+                
+            elif ev.type == pygame.MOUSEBUTTONUP and ev.button == 1:
+                self.point2 = (x, y)
+                
+
+label _image_location_picker:
+
+    scene black
+    
+    python hide:
+
+        image_files = [
+            fn
+            for dir, fn in renpy.loader.listdirfiles()
+            if fn.lower().endswith(".jpg") or fn.lower().endswith(".png")
+            if not fn[0] == "_"
+            ]
+
+        image_files.sort()
+        
+        
+        xadjustment = ui.adjustment()
+        yadjustment = ui.adjustment()
+
+        
+        while True:
+
+            ui.frame()
+            ui.vbox()
+
+            layout.label(u"Image Location Picker", None)
+
+            ui.textbutton(_(u"Done"), clicked=ui.returns(False), size_group="files")
+            
+            ui.side(['c', 'b', 'r'], spacing=5)
+            vp = ui.viewport(xadjustment=xadjustment, yadjustment=yadjustment, mousewheel=True)
+
+            ui.vbox()
+
+            for fn in image_files:
+                ui.button(clicked=ui.returns(fn), size_group="files", xminimum=1.0)
+                ui.text(fn, style="button_text", xalign=0.0)
+                
+            ui.close()
+
+            ui.bar(adjustment=xadjustment, style='scrollbar')
+            ui.bar(adjustment=yadjustment, style='vscrollbar')
+            ui.close()
+
+            ui.close()
+            
+            rv = ui.interact()
+
+            if rv is False:
+                renpy.jump("_developer_screen")
+
+            # Now, allow the user to pick the image.
+
+            ui.keymap(game_menu=ui.returns(True))
+            ui.add(__ImageLocationPicker(rv))
+            ui.interact()
+
+                
+
+        # ...
+
+        renpy.jump("_image_location_picker")
+
+label _filename_list:
+
+    python hide:
+        import os
+        f = file("files.txt", "w")
+
+        for dirname, dirs, files in os.walk(config.gamedir):
+
+            dirs.sort()
+            files.sort()
+            
+            for fn in files:
+                fn = os.path.join(dirname, fn)
+                fn = fn[len(config.gamedir) + 1:]
+                print >>f, fn
+                print fn
+                
+        f.close()
+        
+        renpy.launch_editor(["files.txt"], transient=1)
+        
+    
+    jump _developer_screen
+        
+
+init python:
+    config.underlay.append(im.Tile("_transparent_tile.png"))
+    

common/_layout/classic_joystick_preferences.rpym

@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:
 
     layout.provides('joystick_preferences')
@@ -28,8 +31,6 @@ init python:
     style.js_prefs_button.xminimum = 0.5
     style.js_prefs_box.box_first_spacing = 10
     
-
-    
     config.joystick_keys = [
         (u'Left', 'joy_left'),
         (u'Right', 'joy_right'),
@@ -42,8 +43,6 @@ init python:
         (u'Hide Text', 'joy_hide'),
         (u'Menu', 'joy_menu'),
         ]
-
-    
     
     def _joystick_select_binding():
 
@@ -55,8 +54,8 @@ init python:
             layout.button(_(label) + " - " + _(_preferences.joymap.get(key, u"Not Assigned")), "prefs_js", clicked=my_clicked, index=label)
     
     def _joystick_get_binding():
-        ui.add(renpy.display.joystick.JoyBehavior())
         ui.saybehavior()
+        ui.add(renpy.display.joystick.JoyBehavior())
 
     def _joystick_take_binding(binding, key):
 
@@ -79,7 +78,7 @@ init python:
                 ui.close()
 
                 _joystick_get_binding()
-                binding = ui.interact()
+                binding = ui.interact(mouse="gamemenu")
                 _joystick_take_binding(binding, key)
                 
                 return True
@@ -104,7 +103,7 @@ label joystick_preferences_screen:
         python:
             layout.navigation("joystick_preferences")
             _joystick_preferences()
-            ui.interact()
+            ui.interact(mouse="gamemenu")
 
             
         

common/_layout/classic_load_save.rpym

@@ -1,3 +1,6 @@
+# Copyright 2004-2011 Tom Rothamel <pytom@bishoujo.us>
+# See LICENSE.txt for license details.
+
 init python:
 
     layout.provides('load_save')
@@ -73,7 +76,9 @@ init python:
         
         ui.button(style=style.file_picker_entry[index],
                   clicked=clicked,
-                  role=("selected_" if newest else ""))
+                  role=("selected_" if newest else ""),
+                  keymap={ "save_delete" : ui.returns(("unlink", name)) }
+                  )
 
         ui.hbox(style=style.file_picker_entry_box[index])
 
@@ -183,8 +188,11 @@ init python:
             else:
                 base += 1
 
-        return base + int((int(filename) - 1) / per_page)
-
+        try:
+            return base + int((int(filename) - 1) / per_page)
+        except:
+            return base
+        
     # Processes a screenshot.
     def _file_picker_process_screenshot(s):
         return s
@@ -193,36 +201,45 @@ init python:
     # the list of save files.
     def _file_picker(screen, save):
 
-        # The number of slots in a page.
-        file_page_length = config.file_page_cols * config.file_page_rows
-
-        saved_games = renpy.list_saved_games(regexp=r'(auto-|quick-)?[0-9]+')
-
-        newest = None
-        newest_mtime = None
-        save_info = { }
-
-        for fn, extra_info, screenshot, mtime in saved_games:
-            screenshot = _file_picker_process_screenshot(screenshot)
-            save_info[fn] = (extra_info, screenshot, mtime)
-
-            if not fn.startswith("auto-") and mtime > newest_mtime:
-                newest = fn
-                newest_mtime = mtime
-
-        # The index of the first entry in the page.
-        fpp = __scratch.file_picker_page
-
-        if fpp is None:
-
-            if newest:
-                fpp = _file_picker_file_page(newest)
-            else:
-                fpp = _file_picker_file_page("1")
-
-
+        # Should we update the list of saved games?
+        update = True
+        
         while True:
 
+
+            if update:
+
+                update = False
+
+                # The number of slots in a page.
+                file_page_length = config.file_page_cols * config.file_page_rows
+
+                # The list of saved games.
+                saved_games = renpy.list_saved_games(regexp=r'(auto-|quick-)?[0-9]+')
+
+                # Figure out which game is the newest and so on.
+                newest = None
+                newest_mtime = None
+                save_info = { }
+
+                for fn, extra_info, screenshot, mtime in saved_games:
+                    screenshot = _file_picker_process_screenshot(screenshot)
+                    save_info[fn] = (extra_info, screenshot, mtime)
+
+                    if not fn.startswith("auto-") and mtime > newest_mtime:
+                        newest = fn
+                        newest_mtime = mtime
+
+                # The index of the first entry in the page.
+                fpp = __scratch.file_picker_page
+
+                if fpp is None:
+                    if newest:
+                        fpp = _file_picker_file_page(newest)
+                    else:
+                        fpp = _file_picker_file_page("1")
+
+            
             if fpp < 0:
                 fpp = 0
 
@@ -291,9 +308,14 @@ init python:
             ui.close() # slots
             ui.close() # whole thing
 
-            result = ui.interact()
+            result = ui.interact(mouse="gamemenu")
             type, value = result
 
+            if type == "unlink":
+                if layout.yesno_prompt(screen, layout.DELETE_SAVE):
+                    renpy.unlink_save(value)
+                    update = True
+                    
             if type == "return":
                 return value
 
@@ -311,7 +333,7 @@ label save_screen:
             fn = _file_picker("save", True)
 
             if renpy.can_load(fn):
-                if not layout.yesno_prompt("save", u"Are you sure you want to overwrite your save?"):
+                if not layout.yesno_prompt("save", layout.OVERWRITE_SAVE):
                     continue
 
             renpy.save(fn, extra_info=store.save_name)
@@ -325,7 +347,7 @@ label load_screen:
             fn = _file_picker("load", False)
             
             if _load_prompt:
-                if not layout.yesno_prompt("load",  u"Loading will lose unsaved progress.\nAre you sure you want to do this?"):
+                if not layout.yesno_prompt("load", layout.LOADING):
                     continue
 
             renpy.load(fn)