These (especially the timed variants) tend to disrupt
text-to-speech. It's best to just have them speak in a
single block, whih is closest to the human speech pattern.
Fixes#483.
This is a function that contacts an update server and determines
if there is an update available. It does this in a background thread,
so as to not make the game unresponsive.
We now simply deliver "appear", "show", and "hide" to the child,
rather than trying to exploit _hide. The advantage of doing it this
way is that we can preserve the hide state going into show, without
having to transfer it between transforms.
These functions were marked as pure, but weren't actually pure
functions, since the scope they update can change. This change
has them return objects, which are pure.
When a displayable in a screen that has focus/grab is replaced,
we transfer the focus to its replacement. This fixes a problem where
we would transfer grab only, which could lead to a permagrab condition.
Fixes#477.
It doesn't make sense for Play on the sound channel to participate
in get_selected(), since it's very likely the sound will quickly
end.
See: http://lemmasoft.renai.us/forums/ucp.php?i=pm&mode=view&f=0&p=148211
where Play causes Ren'Py to restart the interaction repeatedly.
Setting this property to False hides a button, bar, or hotspot from the
keyboard focus mechanism. This might be useful for games where we
want to hide interface from the user, like hidden object games.
It seems like SDL_image has problems reentrantly loading some
formats, certainly GIF and maybe TGA and BMP. So we whitelist
the common formats (png and jpeg), and lock loads of the rest.
Fixes#426.
They're really the same operation, except invalidation can be
run in the middle of a render. So let's check for that, and
use a single codepath.
This fixes a bug where when something was shown twice, the
invalidate could not take.
See: twelvethousand
The actions (at least the purchase action) requires us be interacting,
so we can go to sleep and let play services take over to handle the
actual transaction.
This requires us to interact in the middle of a callback, so we do
an invoke_in_new_context to make that possible.
The ATL time adjustments only make sense after take_execution_state.
If we're in a context where take_execution_state is never called,
we don't want to do the time adjustments.
So now, we make it a requirement that take_execution_state be called
before doing time adjustments.
Using the object id proved to be error prone when new objects were
created during each iteration of the list (something we support).
This also returns the behavior to what it was in 6.17.
See: Seasons of the Wolf.
We really should be propagating the transform state, but there
isn't really a good way to do that at the moment. (It isn't clear
where we'd store the old state.)
This is a reasonable, if ugly, workaround.
See: http://lemmasoft.renai.us/forums/ucp.php?i=pm&mode=view&f=0&p=147158
This is a function that munges a string beginning with __ in the
same manner that Ren'Py munges names when parsing a file.
jump __test
and:
jump expression renpy.munge("__test")
Previously, ATL transforms began executing when the screen containing
the ATL transform was first shown, which meant that if the transform
changed over the course of screen display, a portion of the new
transform would be skipped.
This prevents an error that was caused by when an exception in
finish_load would cause the .rpy file to load after finish_load
had already started updating data structures.
This displays a placeholder image. The image displayed may be chosen
by the creator, or automatically determined based on the name of the
image being placeheld.
We do this by cheating heavily - avoiding re-preparing screens, and
busting the render cache. This wouldn't work for arbitrary code,
but it's good enough for the theme chooser.
Where sl1 used structural equality to transfer state between
screens sharing the same tag, sl2 can't do that. (Doing so would
require maintaining _name, which is expensive.)
Instead, we allow uses of screens to include an id property,
which explcitly specifies equality of used screens.
By being a displayable, OnEvent is able to invoke actions even when
a screen is not being updated. This is important in the new version
of Ren'Py, which tries to avoid screen updates as much as possible.
While a reserved word, it's the sort of thing we didn't use much,
and that might be used a lot by end users. So we'll try to avoid
adding uses of type, prefering _type instead.
This is purely to make it possible to port sl1 games up to newer
Ren'Py, without rewriting them. This shouldn't be used in new games,
and may go away at some point.
When a parameter to a transition changes, we have a different
transition, so taking the state doesn't work - it means we will
be representing the state of a different transition.
This prevents us from copying transforms that already have had
take_execution_state called. This fixes a regression that caused
copied transforms to reset, and hence the show event to be fired
multiple times.
When the return site exists, we simply return to it. If the return
site disappears, we look up the call site, and return to the next
node, if one exists.
If we're in developer mode, we report an error at this
point. Otherwise, we pop the stack, and try again.
We now treat this as a mute, and do not play the voice file. This
prevents us from emphasizing voice when the user has disabled the
voice of a particular character.
When an emphasized channel is playing, all non-emphasized channels
have their volume lowered. When emphasis ends, the non-emphasized
channels resume their normal volume.
This is a generalization of (and replacement for) #360.
This will break existing games, by changing the volumes in a way
creators will not expect. Let's make this opt in across the board.
Removed it from the various templates since voice stuff is pretty
rarely used, and shouldn't required attention from a new user.
With the new screen system, it's now possible to reuse the same
displayable between two interactions. Such displayables need to
retain grab until they go away, or grab is explicitly released.
This fixes a problem where a constant bar would lose focus after being
adjusted in a way that restarts the interaction, as volume sliders do.
Previously, we were handling this in SDL. However, this conflicted
with the MOUSEMOTION merging - the other event could be moved before
the mouse release, leading to unsightly jumps, and (perhaps) the
viewport being in the wrong place.
We now synthesize the mouse release move in Ren'Py, which lets us
control the order in which it occurs.
Fixes#391.
We had been using the mouse to determine focus at the start of
each interaction. We now only use the mouse to determine focus
if the last event - the event that ended the interaction - was
a mouse event.
Fixes#299.
This includes:
* When predicting, we do not stop on the first exception. Instead, we
keep going, trying to predict what we can.
* This includes screen parameters and arguments as well.
* If we can't evaluate the list part of a for loop, we use [ 0 ] - in
conjunction with the error handling, this should get us
something. In many cases, it gets us everything important.
* Once per if statement, we predict all branches.
This fixes a regression that caused screens without hide transforms to
immediately become empty, even when they should have been used in an
old transition.
There are certain nodes that can't have keywords, like if nodes that
occur after a python statement that defines a variable used by the if
statement.
This change ensures that we only execute the keywords() method if:
* Some keywords are present.
* Nothing precludes the keywords method from running.
The screen's format may not be the for RGBA format we expect surfaces
to be in when we load them into textures. This would cause
FileCurrentScreenshot to break.
Fixes#314.
We would pass say_vbox_properties, which is only used in pre-screens
code. When iterating through a say_list containing multiple
lines of text, we could use say_args from a previous line.
This is optionally a function that returns the size of the OpenGL
viewport in which Ren'Py draws the game. Having this a callback makes
it possible to constrain the sizes of the game window.
For example, this makes it possible to limit the viewport to integer
multiples of the starting window size, as requested in #406.
These are functions to count the number of dialogue blocks and the
number of seen dialogue blocks in the game. This makes it possible
to give an indication of how much of the game text the player has
seen.
The focusable field was not being set correctly, which made the button
participate in the focus mechanism and get the idle background when
it should have been insensitive.
Used screens that take parameters now run isolated from their parent
context. This lets us treat global const variables as constant,
without having to worry about the parent scope redefining them.
Our definition of constant includes field access, indexing, etc. Since
a screens parameter might be mutable (a list, for example), we can't
treat it as const in the general case.
We can analyze parameterized screens more thoroughly than
non-parameterized screens, since the parameters limit what can
be overridden in the screens' scope.
Each product has a name, used to identify it. This name may be
different from the names used in the various app stores, which can be
specified independently.
The SL fixed statement was calling renpy.display.layout.Fixed with
the layout parameter. Since Fixed also supplied a layout parameter
we'd get a crash.
We had previously been assuming the audio started at 0, while
respecting the video PTS. If the PTS of the first video frame was
non-zero, this would lead to the video being delayed behind the audio
and never catching up.
Fixes#386.
This ensures that when we prepare screens - such as after a language
change - the cache is dropped. If we don't do this, sl2 can use old
values for displayable arguments and const displayables.
Do not mark transforms that aren't intended for use in screens - but
may have names that would be common for screen parameters - as const.
This should improve compatibility with older screens.
This is required so we can pass the layout argument to MultiBox,
which makes the distiniction between fixed, horizontal, and vertical
layouts when the style does not.
This allows one to navigate through all of the displayables on the
screen with the cursor keys, without having to do 2-d navigation,
which is what Ren'Py does by default.
Pyttsx would try to invoke TTS from the python process, which
required a ton of dependencies. (Pyobjc and win32api) We now
use subprocess to run platform-specific executables, passing
the text to speak on the commands line.
* Generate alt text only when voice is enabled.
* Allow the text of the children to be interpolated into alt text.
* Alt text for the preferences screen.
This required several fixes, including making sure copy_on_change works
and copying constant displayables if a change to the scope causes a Text
to change its contents.
fixed the path where Ren'Py had the wrong path for the arabic font AdvertisingBold.ttf which created an error message while trying to access "Options" from the inside the game.
This is a function that takes displayables that are being implicitly
added to a widget by ChildOrFixed. We do not want to copy transforms
added this way, which we had been doing, causing problems.
We now only use the newly-created boxes if at least one displayable
has changed. Otherwise, we don't bother, preferring to use the old
box (which likely has been cached).
Transform had a problem parsing arguments with underscores in the
name, like transform_anchor. That's been fixed.
Transform also did a lot of allocation for rare cases, such a
Transform being given an argument with a style prefix,
like hover_xpos. This has been optimized in order to reduce
the amount of allocation required.
This determines if events will be passed to the child of the
transform. This allows one to prevent events from being passed
to the old_widget in an ATL transform.
This is a behavior change, and a potentially dangerous one, since it
could execute arguments with side effects multiple times. But those
should be rare, this provides a nice performance boost, and users
will be able to disable prediction using the new nopredict clause.
There are a couple of caveats here, since non-ascii identifiers
can't be used in python code.
* The names must be defined with the define statement.
* The names can't be accessed in python code.
Stil, something like:
define 彁 = Character("Boy who is not able satisfactorily to explain what a Hrung is, nor why it should choose to collapse on Betelgeuse Seven")
彁 "Don't forget your towel."
should work.
Chinese_Simplified translation for ren'py launcher
Created by huanxuantian
Translate by huanxuantian
Translation version 1.3.b
update to github on 2014-5-25 sun
This restarts the interaction, and then reports the amount of time
it took to do so. This can give us an idea of how much (if any)
performance is being improved by the new screens code.
--compile compiles the script before doing anything else.
--lint is a backwards compatable way of invoking the lint
command. We've been parsing it as an argument for a while, but it
didn't work.
These are displayables that have constant arguments and constant
children, and hence where the same displayable can alwaye be used. We
use a very fast path for these displayables (simply retrieving them
from the cache), and avoid evaluating their children entirely.
Due to inheritance of SLBlocks, we had the problem that
frame:
textbutton "test" xysize (100, 100)
Would pass the xysize parameter to both the textbutton and the frame.
Viewport was broken with sl2, so we now have a compatible
implementation.
Several screen language things are implemented as composite
displayables. For example, a textbutton consists of a Text
and a Button, and a viewport scrollbars "both" consists of
a Side, two Bars, and a Viewport.
The main displayable (stored in _main on the outer displayable) is the
displayable we add children to, and return for get_widget.
This is a workaround for #351, which only seems to manifest on certain
Macs, and hence is proving hard to actually fix. At least with this
change, it will only show up when switching to Arabic. (And may not
show up at all, as it may have something to do with filesystem
encodings.)
Reusing a displayable is possible when we realize that the positional
and keyword arguments of the displayable are the same. We can also
reuse the transform if we apply the same transform to the
displayable.
This fixes an issue where renpy.pause(0) would effectively block
rollback, since there would be no time for the rollback to occur.
(The same issue occurs when pausing for a short time.)
This is a class that can be used to create sentinel objects. Even if
we pickle and unpickle an object of this class, it remains the same
object, as far as the 'is' operator is concerned.
This fixes a problem with the shift+R module backups. (The same
problem 9dec1f32ab tried to fix.)
The reload backup process would back up singletons, but not functions
and methods that used those singletons as default arguments. The
result was that the singletons would change identity, but not
the default arguments - and the code using them would fail in
odd ways.
An example problem this caused is
http://lemmasoft.renai.us/forums/viewtopic.php?p=320775#p320757 .
The major problem fixed here is one where if a transform was
replaced (like one in a screen would be), it would not know that
the old child was being shown. This would prevent the
"<displayable> with <transition>" ATL construct from doing
anything.
Fixes#340.
The raspi one somewhat works (it has problems, such as positioning the
window in the wrong place), but the slowness of the raspi system make
using it problematic.
The x11 mode hasn't been tested.
We now use the .report_traceback method whenever it's available to
produce nicer-looking tracebacks. (Previously, we only used it
for the simple tracebacks, and only for Contexts.)
The regression was introduced by dd4d3410a6,
and shows up in the Sunrider tutorial battle, when the PACT ships
attack with missiles.
The problem was that we were adjusting the times improperly - using
AdjustTimes to make the adjustment. Instead, we want the MultiBox
containing the layer to make the adjustment (which it does when
layer_name is set). This is because the MultiBox handles start
and animation times that are not the time at which the layer
was shown.
This doesn't support arguments yet, and passes everything through to
use_screen. But it does successfully let one include SL2 and SL1
screens inside an SL2 screen.
This queues an event by name. For example, renpy.queue_event("dismiss")
will act like dismiss has been pressed.
This is intended to make it easier to interface Ren'Py with custom
controllers.
The problem would manifest when we did something like
$ renpy.transition(move), and restarted the interaction. We had been
creating a MultiBox with a layers dict, which would adjust the times
for its children. When shown as part of the second interaction, the
times would be reset to 0, and the move would appear to restart.
By getting rid of the layers dict, we prevent this the adjustment
of times from occuring, and things work as expected.
This fixes a problem where we'd inherit padding from the button
style, which could cause the hotspots to show up in odd places.
This would only occur if ui.hotspot was called directly - so almost
never in actual code.
This is necessary for us to have imagemap statements. The imagemap
needs the keywords to be evaluated, and the imagemap needs to be
created before the keywords can be created.
The Applications folder in OS X is large and installers tend to expect apps to stay where they were placed (i.e. the root of /Applications). Since Lion, there's been application category metadata for View --> Arrange by Application Category but if the metadata's not in info.plist, the app gets sorted into "Other" at the bottom.
https://developer.apple.com/library/Mac/releasenotes/General/SubmittingToMacAppStore/#//apple_ref/doc/uid/TP40010572-CH16-SW8 (this applies to all Mac apps, not just those installed through App Store).
The style rewrite prevented direct access to prefixed styles,
which caused prediction not to work. With this change, we
handle the prediction in cython, which has access to
prefixed and unprefixed styles.
This can happen with some game changes, especially when changing
config.developer = True to False. Rather than crashing in this
case, we display an empty screen.
Fixes#320.
Constant positional arguments are evaluated during a prepare phase,
while non-constant arguments are evaluated at runtime. (When a mix
of arguments is given, they are combined.)
If we don't do this, the children will be shown at the timebase
of the layer at_list, which cause huge problems if the children
themselves are being transformed.
It does some wierd direct keyboard access stuff that might change
in future versions of windows or linux, so this seems like a
reasonable bit of paranoia.
This is a feature that scans for changes in file existence and times.
If a file changes, this triggers a restart of Ren'Py, reloading the
script and game.
Directories in the projects directory might contain filenames
that aren't representable in the system encoding. We now
ignore these directories, rather than throwing an exception.
We were already using window_during_transitions for an obsolete
function, and the preference controls all versions of this, rather
than just during transitions.
This is separating the two functions out, since window during
transitions is useful with window show/window hide, and the
auto function should probably trigger window show/window hide.
These allow users to directly set the size of resizable
displayables.
The names are chosen so they don't conflict with height, width, and
size, which are already in use.
To get the console to work, changed the developer menu into a modal
screen that runs in the current context. Changed everything else to
work with this.
Apart from a lot of writing, this consisted of breaking the style
docs up into two files, one for the statements and python, and
a second one for the properties.
This wraps the renpy.layer_at_list function, which allows one to apply
transforms to entire layers. The show layer statement currently takes
at lists and ATL.
A style is too complex if inheritance goes more than 100 layers
deep. The most common reason for this is likely that there's a
loop in the style inheritance graph.
A problem was reported that Ren'Py would crash on a shift+R
reload. It turned out that while displaying the reload message,
Ren'Py would use the attributes from the previous say statement.
This fixes that.
This does not rollback data that is changed between the current
statement and the next checkpoint. The main use case is to be able
to save while a screen is displayed using call screen.
For example, a user can be assigning points to a character in a
screen, save, load, and have the same points assigned.
This is needed because we might be killed by suspend. If we're killed,
we'll reload the game, but persistent data (incl preferences) will be
lost - unless we save it.
This is a method that, when called on a style, returns a list giving,
for each parent of the style:
* The name of the parent.
* A dictionary that, for each property that affects the inspected
style. gives the property name and its value.
This lets us use different styles for different variants. For example,
we can use a style for touch devices that increases the size of
buttons, so the player can touch them.
* Only set the style name if it's not already set. This is for
compatibility with the way the old style code did it.
* Do not auto-create styles beginning with _. This prevents us
from accidentally creating a style that inherits from a
non-underscore style.
* activate_sound and hover_sound are now their own style properties,
and work again.
* Other than that, we ignore the various selected_activate and activate_
style properties.
This was the music used (as a midi file) for the very oldest versions
of the Ren'Py.
We use a 1994 recording by the US Marine Band, taken from
Wikipedia. It's public domain due to age (of the original) and due to
being the work of the US Government (for the recording).
On Windows, RAPT is responsible for detecting the JDK. If RAPT is
missing, the JDK will also be reported missing - even if it's
installed.
Changing the reporting order makes this less confusing.
* Do not cycle saves if the user says no to quicksave.
* Rescan immediately after a save.
* Ensure scan_saved_game always returns a valid result.
Fixes#236, hopefully.
We remove one -O from the python command line. This prevents python
from removing docstrings, which means we can now use renpy.sh to
generate the documentation includes.
When the auto-save thread kicked off at the end of the game, it could
sit there waiting for a screenshot that would never be taken. This
fixes that, both by taking the screenshot and adding timeouts
that should prevent eternal pauses.
It's possible to have the launcher without the tutorial or vice versa,
and some Linux distros package Ren'Py in this way. Copying the font
file ensures we work in this case.
This will increase the size of the zip file, but probably not of
the 7z or tar.bz2.
When we get "None" as the name of the language to generate translation
for, we generate it for the None language. We only generate string
translations, as that's the only thing that makes sense to translate
in the None language.
Fixes#203.
`after_checkout.sh` has been using `readlink(1)` to get an absolute path (with
no symlinks) to the renpy root directory. Unfortunately, `readlink -f` is a
GNU extension, and thus unavailable on the BSDs, including OS X.
There are[0] a number of options for those systems. While an exec out to
Python seems like overkill (and is, in fact, a bit slow on my system), the
delay is small enough to not be a problem in a one-time script like this.
Additionally, it seemed silly to include a dozen-line shell function just for
this one usage. Plus, we know for certain the user has Python, because
otherwise they couldn't run Ren'Py. ;)
I included the parens around `print` just to make sure it works with both
Python 2.x and 3.x. I doubt this matters, but I figured I might as well.
If we stop caring about resolving symlinks, this entire line can be replaced
with `$PWD##*`. [1]
[0]: http://stackoverflow.com/q/1055671/120999
[1]: http://stackoverflow.com/a/1371283/120999
Some truetype fonts have bounding boxes that contain the origin. (This
may be becuase of font design, auto-hinthing, or anti-aliasing.) We
deal with these fonts by rendering all the available pixels, even
those to the left of the origin.
This may make the actual area drawn to the screen bigger than the
displayable itself, so we deal with that when necessary.
Fixes#34.
* Make the order more consistent.
* Add rollback ("Back")
* We don't need to make F.Skip so easy to disable - it's no worse
than normal skip when skip unseen is off.
Japanese doc information shouldn't be shown in Japanese, and it should be untranslatable text.
This commit adds two tags: language_LANGUAGE and gettext to support it.
Automatically saving persistent data may be too slow (and might cause
a laptop's hard drive to spin up), so we now save it at shutdown or
when renpy.save_persistent is called.
We also allow creators to register a merge function that's called when
loading updated persistence data from disk.
This provides a way to associate arbitrary information with Ren'Py
save files. (For example, we could store which character's route
we're on, or scoring information.)
This introduces config.save_json_callbacks, which contains callback
functions that add information to the json callbacks.
The new MultiLocation lets us save to multiple locations. We now save
both to the user's save directory and a game-local save directory.
Also, refactored the save location in FileLocation into its own
method.
While only used for saves at the moment, this system will eventually
let us use multiple locations.
This also introduces the SaveRecord object, which is where save data
is stored before we write it to disk.
Now that we're almost always running on a multi-core device, there's
little reason not to just run the auto-save thread whenever we want.
This also will make some of the new save stuff simpler.
Previously, were re-compiling the expressions each time the
ConditionSwitch ran, which was leading to performance problem
when there was an absurdly large number of conditions.
These were required to get the Ren'Py 5.0 demo to run. (You'll need
to create a script_version.rpy file set to (5, 0, 0) to get things
actually working.)
We look in:
* The public directory used by very old RAPT versions.
* The private directory used by newer RAPT versions.
* The getExternalFilesDir directory, used by the newest RAPT versions.
This means that saves will now be placed in a public place, so they
can be copied and otherwise shared.
When additive blending is 1.0, the software renderer will not
display an image. This is probably preferable to the image
displaying incorrectly, since they're likely to be effect
images.
This commit adds in the backend support, for varying the additive
blending factor.
Additive blending will not be added to the (mostly obsolete) software
renderer. Instead, added a way to test if the current renderer
supports additive blending.
Thes won't run when optimization is enabled, which is the default
for Ren'Py. It's better to eliminate them entirely, so we have
the same configuration in testing and production.
This was the behavior of of Ren'Py until switching to Freetype 2.4. The
autohinter more resembles the older Ren'Pys, seems to produce better
forms on most fonts, and fixes spacing issues on broken fonts.
Previously, we used 666 and 777, and expected the user's umask to take
care of adjusting the permissions. Unfortunately, info-zip overrides
the umask, writing world-writable files to disk.
Thanks to Spiky Caterpillar for the bug and the fix.
A greedy load after rollback can roll-back through with statements,
which are turned into with None statements until the start of the
next interaction. (Which is sensible behavior for the rollback
case, but fails when an after_load transition is scheduled.)
Fixes#95.
Previously, we used the angle copy function to copy surfaces, which
used the pygame blit function. The pygame blit function was more
complex and held the GIL while blitting, and led to slowdowns in
loading.
Nogil_copy appears to be safe for Ren'Py, which doesn't use software
surfaces.
The image cache is no longer locked for expensive operations,
such as image loads. While this may cause us to load an image
twice (in rare circumstances), it also lets us preload images
without blocking loads frome the main thread.
than the end of an interaction.
Kicking it off at the end of the interaction lead to bad behavior
where the start of the next interaction would fight with the
preload thread for the image cache lock.
been processed.
This is necessary to deal with the way a size may offer the viewport
a smaller area than initially necessary, once scrollbars take up
some space.
Fixes#88.
The segfaulting occured when a TTF Font contains a GSUB table with a
Lookup type other than one. This caused us to initialize a data
structure that represents the lookup table, but never fill it in.
Rarely, one of these tables would hava field initalized to 1 or 2. In
that case, we'd try to free associated data that was never properly
initialized, and we'd crash.
The fix was to intialize the data structures before use.
This involved breaking the prediction coroutine, and the context
prediction routine up further. By predicting one statement at a time,
we can interleve predicitions with frame display, and prevent
dissolves or ATL transforms from starving the image predictor, at
least in simple (non-screen) cases.
Before this change, code that created and then immediately modified a
list, dict, set, or object that was rollback-able would cause a small
memory leak until the end of the interaction.
This helps ensure that code that creates many text objects in a
single interaction will now consume unbounded memory if it lets
those Text objects be GCed.
Window preference.)
This prevents the possibility of spurious resize events, and also
prevents the black bars from appearing on the screen after such
a resize.
Previously, we would load entire files into RAM, compress the entire
file, and write out the compressed data. This was breaking down on
large .rpas, hence the change.
We use ZWSP in input so we properly size an empty line. Some fonts
do not include this character, and replace it with an undefined
character glyph (often a square).
This fix prevents Ren'Py from rendering the ZWSP, making the
problem invisible to the user.
It didn't work on windows, since windows locales work using the ANSI
code page, and there's no way to get them to use UTF-8 or unicode.
(Also, having multiple locale names is asking for problems.)
We generate template/game/screens.rpy from tutorial/game/screens.rpy -
but now, the tutorial version has the language preference in it. We don't
want the language preference to be in the default template, so we use
distribute.py to filter it out.
This prevents an issue that was triggered by an old screen hanging
around during a game restart, but that screen using a variable that
is no longer defined after game start.
This fixes#65, a bug where [1, 2, 3] * 4 would produce a RevertableList,
but 4 * [1, 2, 3] would produce an unwrapped list (that doesn't
participare in rollback).
A bunch of small changes, but the big one here is that we now generate
the mac app from scratch, using the plist creation code that was
checked in earlier.
This transforms the anchor using the same matrix as the rest of
the transform, essentially allowing the point around which the
image rotates/zooms to be specified.
This could happy in various cases, such as when the show and hide
operations were called. The result is that the time inside an
interpolate could go massively negative, and we'd get overly-long
delays and other artifacts.
This triggers the slow text callback, which might be needed to end
something called in one of the other callbacks. (For example, the
PW-style beeping speech.)
* Update the linebreaking to the algorithm and tables in unicode 6.2.
* Implement japanese-strict, japanese-normal, and japanese-loose breaking methods.
This reverses the order of an hbox or vbox's children. For example, in
a box_reversed hbox, the first child will be rightmost, and the last
child will be leftmost.
Vertical text is now automatically rotated to the vertical
orientation.
Add the vtext image and vcentered character, which are the
vertical-text equivalents of image text and centered.
* Taking execution state now works with nested Transforms.
* An ATL transform will take the child of the Transform it replaces,
if it has no child of its own.
The problem we had was that the REDRAW and TIMEEVENT events weren't
scheduled until the prediction coroutine was run. When prediction was
taking a while, the events wouldn't cancel it.
This manifiested as slow skipping, among other problems.
Greedy rollback rolls back as far as it can without crossing a
checkpoint. Non-greedy rollback rolls back to the start of
the checkpoint statement, or the start of the current
statement if we're in a statement.
(This is used by the console to get back to the start of the
current statement.)
The problem is that when we have two rollbackable contexts sharing
a store, variable changes in the inner context aren't rolled back
when a rollback occurs in the main context.
This adds initial support for the memory mode, where we replay
a scene in a new context.
This requires a bunch of changes to rollback, so that it is possible
to rollback a context other than context[0]. Most notably,
RestartException has been replaced by RestartContext and
RestartTopContext.
This also fixes a bug where the rollback_limit was being decremented
even when a checkpoint wasn't reach. This manifiested as a reduced
amount of rollback, especially at the start of the game.
There's two parts to this. First off, there's a new "Generate
Translations" option, which lets the creator or translator generate
the translation files. Then, I added the ability to change the language
the launcher itself uses.
This removes the old .rpt support, and replaces it with a translate
string statement. The RENPY_UPDATE_STRINGS statement now writes
a .rpy file containing the new strings.
This adds a new pass to script loading, one where Ren'Py iterates
through the script and groups say statements and translatable user
statements into translate blocks.
To support the new voice tag feature, character gains a voice_tag
parameter, and the new config.voice_tag_callback variable comes into
existence. When a character speaks, config.voice_tag_callback is
called with that character's voice tag.
This is the last use of a command-line argument in code that isn't
part of the run command. We can now start a Ren'Py game with a
command other than the run command.
This is a minor behavior change. Before this, renpy.play would stop
the playing sound if called with None - which is the default in a lot
of circumstances.
This lets us register a group of fonts, with each covering a portion
of the unicode character space. A string can then be segmented based
on this, dividing it up into runs of characters using various fonts.
The problem is that python seems to generate two kinds of code to
access module globals. Variable access in the global scope uses object
methods, and so setitem and delitem are called. But when a global
is accessd from a function, the dict is accessed directly, and so
we can't intercept them.
This means that the new O(1) method of determining what changed in
the store is massively broken.
Ren'Py now uses an O(n) method of detecting store changes, which
is what we used in 6.13, modified to support multiple stores.
* Always display the first frame of a video.
* Improve sync at the start of a video.
* Update the Movie displayable on a regular basis, even if a movie isn't playing. (This
lets a movie start playing later.)
Fixes#24.
6.13.
This fixes crashing bugs that may have been caused by data structures
being updated while the audio callback is being run in the background.
The big change between 6.13 and this is that playing_name is now
protected by a mutex. PSS_playing_name only tries to grab this mutex,
and doesn't grab the SDL audio lock, preventing it from blocking if
video decoding is too far behind.
If the height of the glyph is small, horiBearingY returns
a non-expected value for vertical layout simulation, but bbox.yMax
returns the same value for all glyphs.
When we error-handle a failure that occurs while rendering, it's
possible that one or more Renders will be kept alive in a
traceback. This prevents us from giving the render-leak warning in
this case.
A movie stop is necessary when the software renderer is being used
because setting the mode will kill the surface that the movie is
drawing to. In GL mode, we use a different surface, so a reset
isn't necessary.
We had been checking that the _chosen dict was non-empty in ChoiceJump
and ChoiceReturn actions. This wasn't necessary given the logic of the
program, and failed in the case of a game that hadn't been played
before.
Fixes http://lemmasoft.renai.us/forums/viewtopic.php?p=214590#p214590
We now generally synchronize video to wall time. We adjust this
synchronization slowly if we're slightly out of sync with the audio,
or by a lot if we're way out of sync.
This ensures that the frame rate remains stable even if the times of
audio decode vary a bit.
We also now support the Movie displayable again.
Previously, video playback was done using SDL events. This was at best
laggy, as the time it took for an SDL event to be delivered was up to
30 ms. Worse, if an event was ever lost, video playback would stop,
packets would queue up, and eventually audio playback (and Ren'Py
itself) would crash.
In the new approach, when a video is playing Ren'Py polls the video
system for new frames. Busy-waiting (with short sleeps to give control
to the decoder threads) ensures that frames are draw promptly, and
so the buffers can't fill up.
This code doesn't explicitly address latency, so that's a wash.
Previously, we limited the maximum size of a texture that Ren'Py could
deal with to 512, and mandated the textures were 66% full. In the movie
case - with a lot of texture uploads - this was bad news, as making new
textures is slow on an intel GPU. So now, we can ask for a big texture
to be created in a single chunk.
Also, we now use 1024px textures, instead of being limited to 512px.
Analogue passes floats to Grid, which passes them to range(), which changed
its behavior in python 2.7 to crash when it gets something other than an
integer.
This fixes a bug where, if a project existed already, the user could
try to launch it, and it would try to create navigation.json in a
directory that didn't exist.
In 6.13.11, __dirty was a boolean. In 6.13.12, it change to an object with
a field - but loading a 6.13.11 game would overwrite that, causing crashes.
Having a totally new variable fixes the problem.
Edwin's fix at 81c265c didn't work when an adjustment was ranged more
than once, with smaller and larger values, as it would shrink to fit
the smaller value. This version applies the in-range check when the
value is accessed.
Zsync only produces output when its stdin is a terminal, which isn't
the case on windows. Attempts to recompile it to change this
behavior proved fruitless.
So instead, we look at the downloaded file, and see how closely it
matches the correct file. (By downloading a list of hashes for each
64k block in the correct file.)
To make builds more convenient, functionality was added to the
launcher to allow the command line tool to not build updates,
and to build a subset of packages.
When the user goes to edit something and no editor has been selected,
the launcher will prompt the creator to select an editor. If the editor
selected is not installed, it will be downloaded and installed.
Movetransition now interpolates the positions of the image
in the before and after cases. This means that if the image is
moving in one or both of the cases, it will be moved between the
two locations.
The new movetransition uses transforms to specify where to move
to and from, rather than factory functions.
It's easier to use, but somewhat less flexible.
The old move transition is around as OldMoveTransition, and compat
will swap it in based on the script version.
The break in the bar could be a non-integer number of pixels, causing
both the left and right sides of the bar to be rounded down and the
total bar to lose a pixel of length.
and easier to use.
The xzoom and yzoom properties are now applied before, rotation. This means
that the shape of the image will remain consistent as the image is rotated.
Previously, the image to change shape as it was rotated.
The xzoom and yzoom properties may now be negative, with negative zoom
values causing the images to be flipped. The positioning code now takes
this into account, and positions a flipped image properly.
This fixes a bug that would cause lines to be too long - the lines
were correct in texwrap, since widths were fine as ints, but expanded
when rendered with the full glyph advances.
This is for compatibility with 6.10 and prior versions of Ren'Py, and
because it makes sense. Zooming an image wants to create an image with
a non-integer width and height. This is especially true when xalign is
non-zero - we need to take the precise width into account when
centering the displayable (at least when using subpixel precision).
It's possible to have a font's bitmap go above its ascent. When this
happened, we would write outside of memory. This fixes that bug by not
drawing - it might render the font wrong, but it should prevent
crashing.
This is a list of functions that are called at the end of each Python
block. One use of this would be to allow variables to manipulated with
normal mathematical operators, and then have a callback ensure that
they remain within a range.
When using negative kerning, we can have a line of text with a
fractional computed width. Rounding down this case lead to the last
pixel being cut off.
We want one layer of overlay pages in the launcher. This lets
us replace the current page with other info, and then easily and
automatically get back to the main page.
Tried a stack, but it's too complex for our needs.
means that it's no longer possible to raise the volume from within Ren'Py.
Controlling the system volume exhibited bugs on all three platforms, including
hard-to-predict volume changes that affect other applications.
to that of their ground image. (Previously, they took up the entire
screen.) This change makes it easier to position an imagemap at a
different location on screen, such as the bottom.
Imagemaps now take an alpha argument. If true (the default), hotspots
are only focused if the mouse is over a non-transparent part of the
idle or hover image. If set to false, the hotspot is focused whenever
the mouse is within its boundaries.
the ui functions.
Changed the _replaces method to be a replaces constructor parameter.
Make the periodic method take st.
Add a periodic method to BarValue.
Implement AnimatedValue.
file can be run from the command line to build distributions in shell
scripts and other automated processes.
Plug games.renpy.org when building distributions.
Change xoffset and yoffset in transforms so that they stack with that
of the child.
pads rotated displayables. When set to False, _not_ the default, it's
now possible to rotate a (100, 50) displayable by 90 degrees, and have
the result be (50, 100) in size.
Rewrote the scene lists. This added support for "replaced" images, but
more importantly, cleaned up the code quite a bit, by making it be in
terms of objects rather than tuples.
Tweak config.default_transform behavior so that it only applies to
non-transforms, so we better match the old behavior.
fix renpy.ui.Many to work with with.
properties to be set using a single parameter. The new composite style
properties are:
* pos - takes a pair, and uses it to set xpos and ypos.
* anchor - takes a pair, and uses it to set xanchor and yanchor.
* align - takes a pair, and uses it to set xalign and yalign. (And
hence xpos, ypos, xanchor, and yanchor.)
* area - take (x, y, height, width) pair, and tries to set properties
such that the displayable will be placed inside the rectangle. This
sets the xpos, ypos, xanchor, yanchor, xfill, yfill, xminimum, yminimum,
xmaximum, and ymaximum properties.
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.
false positives where pylint isn't able to fully analyze Ren'Py.
Add annotations to Ren'Py to further supress false positives. The result
is that we can now run pylint and pick out regressions.
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.
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.
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.
something like {image=eileen happy} is legal, if odd.
Fixed a bug that could prevent files from being loaded if Ren'Py was
run from a path that contains non-ascii characters. (Even in directories
that were not part of the Ren'Py distribution.)
renpy.display.pgrender.surface and other functions in that
module. This function creates a surface with a 1px border in
all directions. This will let us not have to worry about transform32
overrunning the surface.
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.
ATL typo.
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.
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.)
argument, which is can be used to specify images to replace the
text of a yes/no prompt.
Make buttons give out the role + hover status.
Allow transform to control the render size of its child.
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.
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.
rollback if it was not being referred to by an object in the current
state. For example, if we did:
$ o.foo = [ ]
"point a"
$ o.foo.append(1)
"point b"
$ o.foo = None
"point c"
and then rolled back from point c to point a, o.foo would improperly remain
[1]. (And would become bigger each time we rolled back and forth.)
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.
The new renpy.get_placement function returns information about the
placement of displayables.
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.
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.
unscrollbable scrollbars are displays. None keeps the current
behavior, which shows the bar normally. If set to "insensitive", the
bar becomes insensitive, while if set to "hide", the bar is not
drawn at all.
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.
The new RENPY_SCREENSHOT_PATTERN environment variable lets you
configure the name of screenshot files. Ren'Py can now write out
screenshots as JPGs, as well as PNGs.
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
is mapped to Command on the Mac, so Command-q now works on Macintosh.
Alt/Command-h hides (iconifies) the window.
as the icon of the windows exe when building the windows
distribution. Similarly, the file icon.icns will be used as the icon
of the Macintosh application. (Note that .icns is a different file format
from .ico.)
The Macintosh application will now show the name of the game in the
menu bar, rather than "Ren'Py Launcher".
parent of a style. The new style.rebuild function allows styles to be
rebuilt even after the game has begun running, with some
caveats. (Changes are not persisted, for one thing.)
The new renpy.easy_displayable method can be used by user-defined
displayables to convert strings into Solid or Image displayables.
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.
allows you to specify one or more outlines, including offset
ones. This allows for several fairly complicated text effects, similar
to what you'd see in modern subtitles. [demo]
* We believe the bug preventing fonts from being archived has been
fixed. It should now be possible to include a font in an archive, and
have that work. The archiver has been modified to allow this.
improve smoothness on fast enough machines.
Ren'Py now scans the game directory for all .rpa files, and adds them
to config.archives automatically. In addition, the archiver tool now
prompts for the name of archives, and uses filename patterns to decide
what to archive. This makes it easier to break the files up into
multiple archives, in a single game.
encountered.
Fixed a bug that prevented im.AlphaMask and ImageDissolve from working
with some images. Also improved the quality of im.AlphaMask, which was
incorrectly blending fractional alphas with black.
with some images.
Using stdin for the remote control didn't work on Windows, and could
lead to errors in some cases. Instead, the remote control mode now
uses a file, which gets deleted after processing the command.
begin the pause once all text has been displayed.
Lint will no longer produce an error when encountering a user-defined
text tag of the form: {/=style}.
transition that occurs after a game has been loaded. [doc]
Calling renpy.restart_interaction() will no longer cause ongoing
transitions to be terminated. [test, doc]
take 4- and 5-component tuples, respectively. In both cases, the new
last component is a python expression that must be true for the button
to be shown.
Pressing control will no longer cause transitions to end when
config.allow_skipping is False.
optionally takes an adjustment object, which is what stores
information about the range, value, page size, and step size of
the bar. [doc]
Bars now take a new style_property, bar_resizing. If this is true, we
resize sub-bars, rather than rendering them at the full bar size and
then cropping. This changes the look of bars a bit.
Viewports now use adjustments to control their x and y scrolling
information. They properly fill in a range and step size, allowing
scrollbars to indicate the fraction of the viewport that is being
displayed to the user. [doc]
Viewports now also support several new ways of scrolling around. If
a true mousewheel argument is given to ui.viewport, the user will be
able to scroll the viewport using the mousewheel. If the draggable
argument is true, then the user will be able to drag the viewport
around using the mouse. [doc, implement draggable, doc config.keymap]
expression with the values of dynamic variables found inside the
function that has been called.
Added a new variable, _mouse_visible, that controls if the mouse
should be visible at any given moment. [doc]
renpy.with_statement and ui.interact now take a clear argument, which
controls if the transient layer is cleared at the end of a transition
or interaction. [doc]
The new At function provides a nicer syntax for applying position
objects (the result of Position, Move, etc.) to displayables. [doc]
rewritten. It is now possible for hyperlinks to span more than one
line. It is also possible to have code run when a hyperlink has been
focused, using the config.hyperlink_focus callback.
This necessitated some changes to how hyperlinks work. They are no
longer buttons, so style.hyperlink is no longer used... now, only
style.hyperlink_text is used to change the look of a hyperlink.
The new im.AlphaMask image operator lets you use an image to
alpha-mask another. The new config.missing_image_callback lets you
specify a function that's called when an image is missing. Together,
they provide the necessary infrastructure for JCC--- JPEG Compression of
Character art.
displayables. This involved making public the types renpy.Displayable,
renpy.Render, and renpy.IgnoreEvent; and the functions renpy.render,
renpy.redraw, and renpy.timeout.
config.developer is true. [elaborate, doc, implement]
The activate_ property prefix has made a comeback. This prefix is
applied to buttons that have been selected by the user. It is applied
when the button is first selected (while the clicked function is
running). If the clicked function returns a non-None value, or an
exception, then the button remains activated forever. [doc]
The new xoffset and yoffset placement properties allow one to specify
a pixel offset to the position computed using xpos/xanchor and
ypos/yanchor. This makes it easy to specify, say, that a button's
label should be a pixel or two above center. [doc]
The default roundrect theme now takes a new argument, less_rounded. If
True, this will use the 6-pixel rounded rectangles, even on an 800x600
game. This is the default for new projects. [doc, implement]
Setting _game_menu_screen = None prevents the game menu from being
shown. (Setting it to a value like "_save_screen" or "_load_screen"
shows the game menu again.) This is the default during the
splashscreen. [doc]
shown. (Setting it to a value like "_save_screen" or "_load_screen"
shows the game menu again.) This is the default during the
splashscreen. [doc]
NVLCharacter has a new parameter, clear, that if true causes the nvl-mode
screen to be cleared after that character speaks. [doc]
Rewrote the input handling code. Now, we can deal with keysyms prefixed
with alt_, shift_, and noshift_.
renpy.movie_cutscene so that it allows a delay of None, which will
delay until the user clicks. (Note that you still need to specify
loops=-1 in this case.) [doc]
Ren'Py itself. Supplying the --trace option to Ren'Py will write
information about function calls to trace.txt. Supplying --trace twice
will also dump information about line execution and function
returns. Note that trace mode comes with a significant speed penalty,
when active.
statement is allowed to be dismissed, by setting
config.say_allow_dismiss. ui.saybehavior has been updated with similar
functionality. This was added to support children's games, where
dismissing dialogue before it's fully spoken harms the value of a game
as a pedagogical tool... this functionality should not be used in visual
novels aimed at adults.
be used to replace the buttons and labels (respectively) found on the
game and main menus with image-based replacements.
The new focus_mask property allows image buttons to take a mask image
that defines where the mouse must be for it to be focused. The
focus_rect property lets a subrectangle be used to specify focus, when
two imagebuttons overlap.
functions.
Modified the launcher so the user can chose which files are archived
by the "Archive Files" tool. (Which has been renamed from "Archive Images".)
Fixed a bug that prevented new projects from being created under
Linux.
config.has_voice when assigning mixer names to channels. If all of
these are set False, sound will be disabled. If only some are set,
only those mixers will control system volume.
contained within init blocks. It has long been an error to run an
image statement outside of an init block, so this primarily checks for
useless init statements.
statements the same internal name they had in the previous version of
the script. This means that it's now usually possible to load in a
changed script, and come back to roughly the spot where you left
off. (Previously, the closest we would come is the prior label.) Of
course, variables are given the values they when the game was saved.
This allows us to implement a new feature. Pressing shift+R when
config.developer is set saves the game, reloads the script from disk,
and then reloads the game. Doing this generally brings you to the last
unchanged line seen before saving, making it easy to edit the script
and then see your changes in action. Like many developer features,
this may not work perfectly in all circumstances.
when they occured in interactions beginning with a transition, when no
events occured during the interaction. A symptom of the bug was that
if the user moved the mouse, the pause would immediately terminate and
the game would advance.
statements the same internal name they had in the previous version of
the script. This means that it's now usually possible to load in a
changed script, and come back to roughly the spot where you left
off. (Previously, the closest we would come is the prior label.) Of
course, variables are given the values they when the game was saved.
colors, one of which replaces white and one which replaces
black. This is accessed through im.Twocolor. This effect can also be
applied to SFonts using the black_color style property.
uppermost full-screen image that does not have an alpha channel.
Images below this image cannot be seen, and now are not drawn. This
optimization only considers the presence or absence of an alpha
channel, and not the content of that channel. So a PNG image with an
alpha channel that has full opacity will not trigger this
optimization, while the same image with the alpha channel removed will.
xanchor, ypos, and yanchor.
There are now two new properties, xalign and yalign. Assigning to xalign
is equivalent to assigning the same value to xpos and xanchor, and
similarly for yalign. This means that it is now possible to write
xalign=0.5 to center a displayable, rather than having to write
xpos=0.5, xanchor=0.5. [doc]
color is supplied to a SFont, the supplied image is remapped so that
each channel has its value interpolated between 0 and the supplied
color. Most importantly, this means that white pixels will have the
supplied color. This functionality means that drop shadows are now
rendered correctly.
config.with_callback has been changed. It now takes two arguments. The
first is the transition being performed. If this transition is a None
transition created as part of a scene, show, or hide statement, then
the second argument is the transition found in that
statement. Otherwise, it is None. config.with_callback is now requried
to return a transition, which replaces the specified
transition. Hopefully, this is enough to make with_callback useful, by
always giving the callback information specified by the user.
+++
Fixed a bug in renpy.music.set_music, in which the test was inverted
in the code. (But not in the documentation.) Flagged this as requiring
an update, as it could require script changes.
the slow text effect. This may be a regression, but it's fixed now.
Ren'Py now takes some new command line options:
* --savedir allows the user to set the directory in which Ren'Py saves
data in. This allows Ren'Py games to be run from a non-writable
directory.
* --version prints the version of Ren'Py.
OGG Vorbis and especially OGG Speex files. Also, made voice
automatically sustain through pauses.
Fixed a bug in Ren'Py that was causing the voice extra to
malfunction. The bug was caused by the contents of the config
namespace being copied at the wrong time, leading it to not be
restored properly to default values when Ren'Py was reset (as the Main
Menu choice.)
Removed a leftover debugging statement that caused Ren'Py to spew out
all of the say statements in .rpy files it parsed.
rather than just images with filenames. It was also updated to support
tuples, corresponding to composing one image atop another, and lists,
which display things in sequence. To support this, the tuples used by
gallery take a third argument which gives a filename which is used,
somewhat indirectly, to compute the thumbnail.
Empty strings are now allowed in Say statements, although it's not
immediately obvious to me why they would be used, except in some
strange cases, or as placeholders.
contiguously on disk. This allows us to use disk access to retrieve
files from archives, whereas previously the files had to be
reassembled in memory before use. Eliminating this memory assembly can
drop the resident size of Ren'Py significantly. (When music was
playing, there was a memory overhead equal to double the size of the
playing file... this has been eliminated.) While Ren'Py remains
compatible with the older-format archives, regenerating the archives
for a game allows it to take advantage of the new format.
time, rather than pausing and restarting sound playback as
necessary. This eliminates popping and errors in some edge cases, like
playing a very short sound.
<p>To advance through the game, <tt>left-click</tt> or press the <tt>space</tt> or <tt>enter</tt> keys. When at a menu, <tt>left-click</tt> to make a choice, or use the arrow keys to select a choice and <tt>enter</tt> to activate it.</p>
<p><aname="Game_Menu"id="Game_Menu"></a></p>
<h3><spanclass="editsection">[<ahref="/w/index.php?title=renpy/Help&action=edit&section=2"title="Edit section: Game Menu">edit</a>]</span><spanclass="mw-headline">Game Menu</span></h3>
<p>When playing a game, <tt>right-click</tt> or press the <tt>escape</tt> key to enter the game menu. The game menu gives the following choices:</p>
<dl>
<dt>Return</dt>
<dd>Returns to the game.</dd>
<dt>Save Game</dt>
<dd>Allows you to save a game by clicking on a save slot.</dd>
<dt>Load Game</dt>
<dd>Allows you to load a game by clicking on a save slot. Clicking on "Auto" accesses the automatic save slots.</dd>
<dt>Preferences</dt>
<dd>Changes the game preferences (options/configuration):
<dl>
<dt>Display</dt>
<dd>Switches between fullscreen and windowed mode.</dd>
<dt>Transitions</dt>
<dd>Controls the display of transitions between game screens.</dd>
<dt>Text Speed</dt>
<dd>Controls the rate at which text displays. The further to the right this slider is, the faster the text will display. All the way to the right causes text to be shown instantly.</dd>
<dt>Joystick</dt>
<dd>Lets you control the game using a joystick.</dd>
<dt>Skip</dt>
<dd>Chooses between skipping messages that have been already seen (in any play through the game), and skipping all messages.</dd>
<dt>Begin Skipping</dt>
<dd>Returns to the game, while skipping.</dd>
<dt>After Choices</dt>
<dd>Controls if skipping stops upon reaching a menu.</dd>
<dt>Auto-Forward Time</dt>
<dd>Controls automatic advance. The further to the left this slider is, the shorter the amount of time before the game advances. All the way to the right means text will never auto-forward.</dd>
<dt>Music, Sound, and Voice Volume</dt>
<dd>Controls the volume of the Music, Sound effect, and Voice channels, respectively. The further to the right these are, the louder the volume.</dd>
</dl>
</dd>
</dl>
<dl>
<dt>Main Menu</dt>
<dd>Returns to the main menu, ending the current game.</dd>
<dt>Help</dt>
<dd>Shows this help screen.</dd>
<dt>Quit</dt>
<dd>Exits the game; the game will be closed and ended.</dd>
<h3><spanclass="editsection">[<ahref="/w/index.php?title=renpy/Help&action=edit&section=3"title="Edit section: Key and Mouse Bindings">edit</a>]</span><spanclass="mw-headline">Key and Mouse Bindings</span></h3>
<dl>
<dt>Left-click, Enter</dt>
<dd>Advances through the game, activates menu choices, buttons, and sliders.</dd>
<dt>Space</dt>
<dd>Advances through the game, but does not activate choices.</dd>
<dt>Arrow Keys</dt>
<dd>Selects menu choices, buttons, and sliders.</dd>
<dt>Ctrl</dt>
<dd>Causes skipping to occur while the ctrl key is held down.</dd>
<dt>Tab</dt>
<dd>Toggles skipping, causing it to occur until tab is pressed again.</dd>
<dt>Mousewheel-Up, PageUp</dt>
<dd>Causes rollback to occur. Rollback reverses the game back in time, showing prior text and even allowing menu choices to be changed.</dd>
<dt>Mousewheel-Down, PageDown</dt>
<dd>Causes rollforward to occur, cancelling out a previous rollback.</dd>
<dt>Right-click, Escape</dt>
<dd>Enters the game menu. When in the game menu, returns to the game.</dd>
<dt>Middle-click, H</dt>
<dd>Hides the text window and other transient displays.</dd>
<dt>F</dt>
<dd>Toggles fullscreen mode</dd>
<dt>S</dt>
<dd>Takes a screenshot, saving it in a file named screenshotxxxx.png, where xxxx is a serial number.</dd>
<dt>Alt-M, Command-H</dt>
<dd>Hides (iconifies) the window.</dd>
<dt>Alt-F4, Command-Q</dt>
<dd>Quits the game.</dd>
<dt>Delete</dt>
<dd>When a save slot is selected, deletes that save slot.</dd>
<dt>v</dt>
<dd>Toggles self-voicing mode, which reads text to the user using an os-supplied
speech synthesizer. For more information, please read the <ahref="http://www.renpy.org/dev-doc/html/self_voicing.html">self-voicing</a>
<p>This game uses source code from a number of open source projects. For a list, and a location where the source code can be downloaded from, please view the LICENSE.txt file in the renpy directory, or visit <ahref="http://www.renpy.org/wiki/renpy/License"class="external free"title="http://www.renpy.org/wiki/renpy/License"rel="nofollow">http://www.renpy.org/wiki/renpy/License</a> .</p>
contents += _("# Ren'Py automatically loads all script files ending with .rpy. To use this\n# file, define a label and jump to it from another file.\n")
contents += "\n"
try:
os.makedirs(dir)
except:
pass
contents = u"\uFEFF"
contents += _("# Ren'Py automatically loads all script files ending with .rpy. To use this\n# file, define a label and jump to it from another file.\n")
# Copyright 2004-2014 Tom Rothamel <pytom@bishoujo.us>
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
init python:
ANDROID_NO_RAPT = 0
ANDROID_NO_JDK = 1
ANDROID_NO_SDK = 2
ANDROID_NO_KEY = 3
ANDROID_NO_CONFIG = 4
ANDROID_OK = 5
NO_RAPT_TEXT = _("To build Android packages, please download RAPT, unzip it, and place it into the Ren'Py directory. Then restart the Ren'Py launcher.")
NO_JDK_TEXT = _("A 32-bit Java Development Kit is required to build Android packages on Windows. The JDK is different from the JRE, so it's possible you have Java without having the JDK.\n\nPlease {a=http://www.oracle.com/technetwork/java/javase/downloads/index.html}download and install the JDK{/a}, then restart the Ren'Py launcher.")
NO_SDK_TEXT = _("RAPT has been installed, but you'll need to install the Android SDK before you can build Android packages. Choose Install SDK to do this.")
NO_KEY_TEXT = _("RAPT has been installed, but a key hasn't been configured. Please create a new key, or restore android.keystore.")
NO_CONFIG_TEXT = _("The current project has not been configured. Use \"Configure\" to configure it before building.")
OK_TEXT = _("Choose \"Build\" to build the current project, or attach an Android device and choose \"Build & Install\" to build and install it on the device.")
PHONE_TEXT = _("Attempts to emulate an Android phone.\n\nTouch input is emulated through the mouse, but only when the button is held down. Escape is mapped to the menu button, and PageUp is mapped to the back button.")
TABLET_TEXT = _("Attempts to emulate an Android tablet.\n\nTouch input is emulated through the mouse, but only when the button is held down. Escape is mapped to the menu button, and PageUp is mapped to the back button.")
OUYA_TEXT = _("Attempts to emulate a televison-based Android console, like the OUYA or Fire TV.\n\nController input is mapped to the arrow keys, Enter is mapped to the select button, Escape is mapped to the menu button, and PageUp is mapped to the back button.")
INSTALL_SDK_TEXT = _("Downloads and installs the Android SDK and supporting packages. Optionally, generates the keys required to sign the package.")
CONFIGURE_TEXT = _("Configures the package name, version, and other information about this project.")
PLAY_KEYS_TEXT = _("Opens the file containing the Google Play keys in the editor.\n\nThis is only needed if the application is using an expansion APK. Read the documentation for more details.")
BUILD_TEXT = _("Builds the Android package.")
BUILD_AND_INSTALL_TEXT = _("Builds the Android package, and installs it on an Android device connected to your computer.")
CONNECT_TEXT = _("Connects to an Android device running ADB in TCP/IP mode.")
DISCONNECT_TEXT = _("Disconnects from an Android device running ADB in TCP/IP mode.")
$ interface.yesno(_("Before packaging Android apps, you'll need to download RAPT, the Ren'Py Android Packaging Tool. Would you like to download RAPT now?"), no=Jump("front_page"))
_("Please enter the IP address and port number to connect to, in the form \"192.168.1.143:5555\". Consult your device's documentation to determine if it supports remote ADB, and if so, the address and port to use."),
default=address,
cancel=Jump("android"),
)
address = address.strip()
try:
host, port = address.split(":")
except:
interface.error(_("Invalid remote ADB address"), _("The address must contain one exactly one ':'."), label=None)
continue
if " " in host:
interface.error(_("Invalid remote ADB address"), _("The host may not contain whitespace."), label=None)
continue
try:
int(port)
except:
interface.error(_("Invalid remote ADB address"), _("The port must be a number."), label=None)
continue
break
persistent.connect_address = address
rapt_interface = AndroidInterface()
rapt.build.connect(rapt_interface, address)
jump android
label android_disconnect:
python hide:
rapt_interface = AndroidInterface()
rapt.build.disconnect(rapt_interface)
jump android
init python:
def android_build_command():
ap = renpy.arguments.ArgumentParser()
ap.add_argument("project", help="The path to the project directory.")
ap.add_argument("command", help="Commands to pass to ant. (Try 'release' 'install'.)", nargs='+')
interface.error(_("Errors were detected when running the project. Please ensure the project runs without errors before building distributions."))
return
label build_distributions:
call build_update_dump
if not project.current.dump["build"]["directory_name"]:
jump build_missing
call screen build_distributions
label build_missing:
python hide:
interface.yesno(_("Your project does not contain build information. Would you like to add build information to the end of options.rpy?"), yes=Return(True), no=Jump("front_page"))
# The priority of the editor. Lower priorities will come later
# in the list.
self.priority = priority
# The name of the editor.
self.name = name
# Is the editor installed?
self.installed = name in editors
# The dlc needed to install the editor.
self.dlc = dlc
# A description of the editor.
self.description = description
# A description of the download.
self.dldescription = dldescription
# An error message to display if the editor failed to start.
self.error_message = error_message
def fancy_scan_editors():
"""
Creates the list of FancyEditorInfo objects.
"""
global fancy_editors
scan_all()
fei = fancy_editors = [ ]
# Editra.
ED = _("{b}Recommended.{/b} A beta editor with an easy to use interface and features that aid in development, such as spell-checking. Editra currently lacks the IME support required for Chinese, Japanese, and Korean text input.")
EDL = _("{b}Recommended.{/b} A beta editor with an easy to use interface and features that aid in development, such as spell-checking. Editra currently lacks the IME support required for Chinese, Japanese, and Korean text input. On Linux, Editra requires wxPython.")
renpy.invoke_in_new_context(interface.error, _("An exception occured while launching the text editor:\n[exception!q]"), error_message, exception=exception)
renpy.invoke_in_new_context(interface.error, _("An exception occured while launching the text editor:\n[exception!q]"), error_message, exception=exception)
class EditAll(Action):
"""
Opens all scripts that are part of the current project in a web browser.
"""
alt = "Edit [text]."
def __init__(self):
return
def __call__(self):
if not check_editor():
return
scripts = project.current.script_files()
scripts = [ i for i in scripts if not i.startswith("game/tl/") ]
scripts.sort(key=lambda fn : fn.lower())
for fn in [ "game/screens.rpy", "game/options.rpy", "game/script.rpy" ]:
renpy.invoke_in_new_context(interface.error, _("An exception occured while launching the text editor:\n[exception!q]"), error_message, exception=exception)
screen editor:
frame:
style_group "l"
style "l_root"
window:
has vbox
label _("Select Editor")
add HALF_SPACER
hbox:
frame:
style "l_indent"
xfill True
viewport:
scrollbars "vertical"
mousewheel True
has vbox
text _("A text editor is the program you'll use to edit Ren'Py script files. Here, you can select the editor Ren'Py will use. If not already present, the editor will be automatically downloaded and installed.") style "l_small_text"
text _("Please select a template to use for your new project. The template sets the default font and the user interface language. If your language is not supported, choose 'english'.")
interface.interaction(_("PROJECTS DIRECTORY"), _("Please choose the projects directory using the directory chooser.\n{b}The directory chooser may have opened behind this window.{/b}"), _("This launcher will scan for projects in this directory, will create new projects in this directory, and will place built projects into this directory."),)
interface.error(_("Ren'Py was unable to run python with tkinter to choose the projects directory. Please install the python-tk or tkinter package."), label=None)
if code:
interface.error(_("Ren'Py was unable to run python with tkinter to choose the projects directory. Please install the python-tk or tkinter package."), label=None)
elif choice:
path = choice.decode("utf-8")
if path is None:
path = default_path
interface.info(_("Ren'Py has set the projects directory to:"), "[path!q]", path=path)
path = renpy.fsdecode(path)
if os.path.isdir(path):
persistent.projects_directory = path
else:
path = os.path.abspath(config.renpy_base)
project.manager.scan()
return
init python:
def set_projects_directory_command():
ap = renpy.arguments.ArgumentParser()
ap.add_argument("projects", help="The path to the projects directory.")
old "To build Android packages, please download RAPT (from {a=http://www.renpy.org/dl/android}here{/a}), unzip it, and place it into the Ren'Py directory. Then restart the Ren'Py launcher."
new "لتجهيز اللعبة للعمل على اجهزة اندرويد يمكنك تحميل الحزمة الخاصة بذلك {a=http://www.renpy.org/dl/android}here{/a}) و فك الضغط عنها, ثم نسخها إلى مجلد رينباي الرئيسي ثم إعادة فتح هذا المشغِّل."
# game/android.rpy:13
old "RAPT has been installed, but you'll need to install the Android SDK before you can build Android packages. Choose Install SDK to do this."
new "حزمة الاندرويد RAPT موجوده, لكنك تحتاج لتنصيب Android SDK قبل ان تبدأ بتجهيز حزم للعمل على اندرويد. الرجاء اختيار تنصيب Android SDK لتستطيع ذلك."
# game/android.rpy:14
old "RAPT has been installed, but a key hasn't been configured. Please create a new key, or restore android.keystore."
new "حزمة اندرويد RAPT موجوده, لكن المفتاح لم يتم تجهيزه. الرجاء تكوين مفتاح جديد او استرجاع android.keystore"
# game/android.rpy:15
old "The current project has not been configured. Use \"Configure\" to configure it before building."
new "المشروع الحالي لم يتم تجهيز إعدادته. الرجاء اختيار \"Configure\" لتقوم بتجهيزها قبل بناء الحزمة."
# game/android.rpy:16
old "Choose \"Build\" to build the current project, or attach an Android device and choose \"Build & Install\" to build and install it on the device."
new "قم باختيار زر \"Build\" لتقوم بتجهيز المشروع الحالي إلى حزمة قابلة للعمل على اندرويد. او قم بربط جهاز اندرويد و اختيار \"Build & Install\" ليتم تنصيبها مباشرة على الجهاز المطلوب."
# game/android.rpy:18
old "Attempts to emulate an Android phone.\n\nTouch input is emulated through the mouse, but only when the button is held down. Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "يقوم بمحاكاة جهاز اندرويد هاتفي محمول. \n\n خاصية اللمس يتم محاكاتها عبر مؤشر الفأره, لكن فقط حين يكون زر الفأره مضغوطاً. زر الخروج يقوم باستدعاء نافذة القائمة الرئيسية, و PageUp هو زر العودة إلى الوراء."
# game/android.rpy:19
old "Attempts to emulate an Android tablet.\n\nTouch input is emulated through the mouse, but only when the button is held down. Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "يقوم بمحاكاة جهاز اندرويد تابلت. \n\n خاصية اللمس يتم محاكاتها عبر مؤشر الفأره, لكن فقط حين يكون زر الفأره مضغوطاً. زر الخروج يقوم باستدعاء نافذة القائمة الرئيسية, و PageUp هو زر العودة إلى الوراء"
# game/android.rpy:20
old "Attempts to emulate an OUYA console.\n\nController input is mapped to the arrow keys, Enter is mapped to the select button, Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "يقوم بمحاكاة جهاز Ouya. \n\n يد التحكم تتم محاكاتها بأزرار الإتجاهات, زر الإدخال يحاكي select, زر الخروج يحاكي زر menu, و PageUp يحاكي زر العودة."
# game/android.rpy:22
old "Downloads and installs the Android SDK and supporting packages. Optionally, generates the keys required to sign the package."
new "يقوم بتحميل و تنصيب Android SDK والحزم المساندة لها. يعطيك خيار تكوين المفاتيح المطلوبة لتتمكن من استعمال الحزمة."
# game/android.rpy:23
old "Configures the package name, version, and other information about this project."
new "يقوم بتجهيز إعدادات الحزمة, رقم النسخة, و معلومات أخرى تتعلق بهذا المشروع."
# game/android.rpy:24
old "Opens the file containing the Google Play keys in the editor.\n\nThis is only needed if the application is using an expansion APK. Read the documentation for more details."
new "يفتح الملف الخاص بمعلومات مفتاح Google Play في محرر النصوص. \n\n هذه الخطوة غير مطلوبة إلا لو كان البرنامج يحتاج إحدى الحوم المساندة expansion APK. الرجاء الإطلاع على ملفات المساعدة للحصول على المزيد من المعلومات."
# game/android.rpy:25
old "Builds the Android package."
new "يقوم ببناء حزمة للأندرويد."
# game/android.rpy:26
old "Builds the Android package, and installs it on an Android device connected to your computer."
new "يقوم ببناء حزمة للأندرويد, ثم يقوم بتنصيبها على جهاز أندرويد المتصل بحاسوبك."
# game/android.rpy:142
old "{a=%s}%s{/a}"
new "{a=%s}%s{/a}"
# game/android.rpy:361
old "Android: [project.current.name!q]"
new "أندرويد: [project.current.name!q]"
# game/android.rpy:381
old "Emulation:"
new "محاكاة"
# game/android.rpy:389
old "Phone"
new "هاتف"
# game/android.rpy:393
old "Tablet"
new "تابلت/ لوحي"
# game/android.rpy:397
old "Television / OUYA"
new "تلفزيون / OUYA"
# game/android.rpy:409
old "Build:"
new ""
# game/android.rpy:417
old "Install SDK & Create Keys"
new "تنصيب SDK و اختلاق مفاتيح"
# game/android.rpy:421
old "Configure"
new "إعدادات"
# game/android.rpy:425
old "Build Package"
new "بناء الحزمة"
# game/android.rpy:429
old "Build & Install"
new "بناء و تنصيب"
# : Translation updated at 2014-04-17 13:01
translate arabic strings:
# game/android.rpy:30
old "To build Android packages, please download RAPT, unzip it, and place it into the Ren'Py directory. Then restart the Ren'Py launcher."
new "لبناء ملفات الأندرويد, الرجاء تحميل RAPT, ثم فك الضغط عن الملف ووضعه في مجلد رينباي. قد تحتاج لإعادة تشغيل رينباي ليعمل بشكل صحيح."
# game/android.rpy:31
old "A 32-bit Java Development Kit is required to build Android packages on Windows. The JDK is different from the JRE, so it's possible you have Java without having the JDK.\n\nPlease {a=http://www.oracle.com/technetwork/java/javase/downloads/index.html}download and install the JDK{/a}, then restart the Ren'Py launcher."
new "تحتاج لنسخة برمجية من جافا تعتمد الـ 32-بت لتستطيع إنشاء ملفات الأندرويد على نظام الوندوز. حزمة JDK تختلف عن JRE, قد تكون الجافا لديك موجوده لكنها تفتقد الـ JDK. \n\n الرجاء {a=http://www.oracle.com/technetwork/java/javase/downloads/index.html}تحميل و تنصيب JDK{/a} ثم إعادة تشغيل رينباي"
# game/android.rpy:39
old "Attempts to emulate a televison-based Android console, like the OUYA or Fire TV.\n\nController input is mapped to the arrow keys, Enter is mapped to the select button, Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "يحاول محاكاة نظام تلفزيوني للأندرويد مثل جهاز OUYA او Fire TV. \n\n يتم تخطيط الأزرار لعصا التحكم لتناسب ازرار جهاز التحكم عن بعد. Controller input is mapped to the arrow keys, Enter is mapped to the select button, Escape is mapped to the menu button, and PageUp is mapped to the back button."
# game/android.rpy:47
old "Connects to an Android device running ADB in TCP/IP mode."
new "يتصل بجهاز أندرويد يعمل على نظام ADB عن طريق TCP/IP mode"
# game/android.rpy:48
old "Disconnects from an Android device running ADB in TCP/IP mode."
new "يفصل الاتصال عن جهاز أندرويد يعمل على نظام ADB عن طريق TCP/IP mode"
# game/android.rpy:516
old "Other:"
new "آخر:"
# game/android.rpy:524
old "Remote ADB Connect"
new "الإتصال عن بعد عن طريق ADB"
# game/android.rpy:528
old "Remote ADB Disconnect"
new "قطع إتصال ADB عن بعد"
# game/android.rpy:561
old "Before packaging Android apps, you'll need to download RAPT, the Ren'Py Android Packaging Tool. Would you like to download RAPT now?"
new "قبل ان تصتطيع إنشاء ملفات للأندرويد, عليك ان تقوم بتحميل ملفات RAPT الخاصة بتحويل ملفات رينباي للأندرويد. هل تريد ان تقوم بتحميل الحزمة الآن؟"
# game/android.rpy:608
old "Remote ADB Address"
new "عنوان ADB عن بعد"
# game/android.rpy:609
old "Please enter the IP address and port number to connect to, in the form \"192.168.1.143:5555\". Consult your device's documentation to determine if it supports remote ADB, and if so, the address and port to use."
new "الرجاء إدخال عنوان الأي بي ورقم المنفذ المطلوب للإتصال, على شكل \"192.168.1.143:5555\". الرجاء العودة لدليل المستخدم الخاص بجهازك لتعرف إن كان يدعم الإتصال عن بعد للـ ADB و إن كان قادراً على ذلك, ستجد العنوان و المنفذ المطلوبان."
# game/android.rpy:619
old "Invalid remote ADB address"
new "عنوان ِADB خاطيء"
# game/android.rpy:619
old "The address must contain one exactly one ':'."
new "العنوان يجب ان يحتوي على علامة ':' واحده فقط لا غير"
new "فرض استعمال المحركات البرمجية software renderer"
# renpy/common/00gltest.rpy:73
old "Changes will take effect the next time this program is run."
new "سيتم تفعيل التغييرات في المرة القادمة التي تفتح فيها البرنامج"
# renpy/common/00gltest.rpy:77
old "Quit"
new "خروج"
# renpy/common/00gltest.rpy:82
old "Return"
new "عودة"
# renpy/common/00gltest.rpy:112
old "Performance Warning"
new "تحذير عن الأداء"
# renpy/common/00gltest.rpy:117
old "This computer is using software rendering."
new "هذا الجهاز يستعمل software rendering"
# renpy/common/00gltest.rpy:119
old "This computer is not using shaders."
new "هذا الجهاز لا يستعمل shaders"
# renpy/common/00gltest.rpy:121
old "This computer is displaying graphics slowly."
new "هذا الجهاز يستعرض الرسوميات بشكل بطيء"
# renpy/common/00gltest.rpy:123
old "This computer has a problem displaying graphics: [problem]."
new "هذا الجهاز يواجه مشكلة في استعراض الرسوميات [problem]"
# renpy/common/00gltest.rpy:128
old "Its graphics drivers may be out of date or not operating correctly. This can lead to slow or incorrect graphics display. Updating DirectX could fix this problem."
new "محركات الرسوميات قد تكون قديمة او لا تعمل بشكل صحيح. قد يسبب ذلك بطء او اخطاء في الاستعراض, القيام بتحديث directX قد يساعد في حل المشكلة."
# renpy/common/00gltest.rpy:130
old "Its graphics drivers may be out of date or not operating correctly. This can lead to slow or incorrect graphics display."
new " محركات الرسوميات قد تكون قديمة او لا تعمل بشكل صحيح. قد يسبب ذلك بطء او اخطاء في الاستعراض."
# renpy/common/00gltest.rpy:135
old "Update DirectX"
new "تحديث DirectX"
# renpy/common/00gltest.rpy:141
old "Continue, Show this warning again"
new "استمرار, الرجاء عرض هذا التحذير في المرة الثادمة ايضاً"
# renpy/common/00gltest.rpy:145
old "Continue, Don't show warning again"
new "استمرار, لا تعرض هذا التحذير مرة اخرى"
# renpy/common/00gltest.rpy:171
old "Updating DirectX."
new "يتم تحديث DirectX"
# renpy/common/00gltest.rpy:175
old "DirectX web setup has been started. It may start minimized in the taskbar. Please follow the prompts to install DirectX."
new "يتم الآن تنصيب DirectX, قد يبدأ ذلك بشكل مصغر في شريط المهام. الرجاء اتباع التعليمات لاكمال التنصيب."
# renpy/common/00gltest.rpy:179
old "{b}Note:{/b} Microsoft's DirectX web setup program will, by default, install the Bing toolbar. If you do not want this toolbar, uncheck the appropriate box."
new "{b}ملاحظة:{/b} مايكروسوفت دايركت أكس يقوم تلقائياً بتنصيب شريط بينق Bing toolbar. إذا لم ترغب بذلك الرجاء القيام بإلغاء تحديد خانة الاختيار"
# renpy/common/00gltest.rpy:183
old "When setup finishes, please click below to restart this program."
new "حيثن ينتهي التنصيب, الرجاء الضغط ادناه لإعادة تشغيل البرنامج"
# renpy/common/00gltest.rpy:185
old "Restart"
new "إعادة تشغيل"
# : Translation updated at 2013-04-30 07:54
translate arabic strings:
# renpy/common/00keymap.rpy:167
old "Saved screenshot as %s."
new "تم حفظ الصورة كـ %s"
# : Translation updated at 2013-04-30 07:54
translate arabic strings:
# renpy/common/00layout.rpy:421
old "Are you sure?"
new "هل انت متأكد؟"
# renpy/common/00layout.rpy:422
old "Are you sure you want to delete this save?"
new "هل انت متأكد من رغبتك في حذف خانة الحفظ هذه؟"
# renpy/common/00layout.rpy:423
old "Are you sure you want to overwrite your save?"
new "هل انت متأكد من رغبتك في الحفظ على هذه الخانة؟"
# renpy/common/00layout.rpy:424
old "Loading will lose unsaved progress.\nAre you sure you want to do this?"
new "الاسترجاع سيضيع كل ما فعلته منذ خانة الحفظ السابقة. \n هل انت متأكد من رغبتك في الاسترجاع إلى هذه النقطة؟"
# renpy/common/00layout.rpy:425
old "Are you sure you want to quit?"
new "هل انت متأكد من رغبتك في الخروج؟"
# renpy/common/00layout.rpy:426
old "Are you sure you want to return to the main menu?\nThis will lose unsaved progress."
new "هل انت متأكد من رغبتك في العودة للقائمة الرئيسية؟ \n كل ما لم تقم بحفظة سيضيع."
# : Translation updated at 2013-04-30 07:54
translate arabic strings:
# renpy/common/00library.rpy:77
old "Skip Mode"
new "وضع التسريع"
# renpy/common/00library.rpy:80
old "Fast Skip Mode"
new "وضع التسريع السريع"
# : Translation updated at 2013-04-30 07:54
translate arabic strings:
# renpy/common/00updater.rpy:1258
old "Updater"
new "برنامج التحديث"
# renpy/common/00updater.rpy:1267
old "This program is up to date."
new "هذه النسخة هي الأحدث"
# renpy/common/00updater.rpy:1269
old "[u.version] is available. Do you want to install it?"
new "النسخة [u.version] متوفرة, هل ترغب في تنصيبها؟"
# renpy/common/00updater.rpy:1271
old "Preparing to download the updates."
new "يتم التجهيز لتحميل البرنامج من الانترنت"
# renpy/common/00updater.rpy:1273
old "Downloading the updates."
new "يتم تنزيل التحديثات"
# renpy/common/00updater.rpy:1275
old "Unpacking the updates."
new "يتم فك الضغط عن التحديثات"
# renpy/common/00updater.rpy:1279
old "The updates have been installed. The program will restart."
new "تم التحديث.. سيتم إعادة تشغيل البرنامج."
# renpy/common/00updater.rpy:1281
old "The updates have been installed."
new "تم التحديث."
# renpy/common/00updater.rpy:1283
old "The updates were cancelled."
new "تم إلغاء التحديث."
# : Translation updated at 2013-04-30 07:54
translate arabic strings:
# renpy/common/_compat/gamemenu.rpym:180
old "Empty Slot."
new "خانة فارغة"
# renpy/common/_compat/gamemenu.rpym:337
old "Previous"
new "السابق"
# renpy/common/_compat/gamemenu.rpym:344
old "Next"
new "التالي"
# : Translation updated at 2013-04-30 07:54
translate arabic strings:
# renpy/common/_compat/preferences.rpym:411
old "Joystick Mapping"
new "خيارات عصى التحكم"
# : Translation updated at 2013-04-30 07:54
translate arabic strings:
# renpy/common/_errorhandling.rpym:408
old "An exception has occurred."
new "حصل استثناء"
# renpy/common/_errorhandling.rpym:434
old "Rollback"
new "تراجع"
# renpy/common/_errorhandling.rpym:436
old "Attempts a roll back to a prior time, allowing you to save or choose a different choice."
new "يقوم بالتراجع لنقطة سابقة لكي تستطيع اختيار شيء آخر"
# renpy/common/_errorhandling.rpym:439
old "Ignore"
new "تجاهل"
# renpy/common/_errorhandling.rpym:441
old "Ignores the exception, allowing you to continue. This often leads to additional errors."
new "يتجاهل الاستثناء مما يستمح لك بالاستمرار. قد يسبب هذا المزيد من الاخطاء."
# renpy/common/_errorhandling.rpym:444
old "Reload"
new "إعادة المحاولة"
# renpy/common/_errorhandling.rpym:446
old "Reloads the game from disk, saving and restoring game state if possible."
new "يعيد تشغيل اللعبة من القرص الصلب, مع محاولة استعمادة آخر نقطة وحفظها عند الإستطاعة."
# renpy/common/_errorhandling.rpym:448
old "Open Traceback"
new "قراءة التقرير"
# renpy/common/_errorhandling.rpym:450
old "Opens the traceback.txt file in a text editor."
new "يفتح تقرير الخطأ في برنامج الملفات النصية."
# renpy/common/_errorhandling.rpym:456
old "Quits the game."
new "يخرج من اللعبة."
# renpy/common/_errorhandling.rpym:483
old "Parsing the script failed."
new "حصل خطأ أثناء تشغيل النص."
# renpy/common/_errorhandling.rpym:510
old "Open Parse Errors"
new "يفتح قائمة اخطاء التشغيل."
# renpy/common/_errorhandling.rpym:512
old "Opens the errors.txt file in a text editor."
new "يفتح ملف errors.txt في برنامج الملفات النصية"
# : Translation updated at 2013-04-30 07:54
translate arabic strings:
# renpy/common/_layout/classic_load_save.rpym:152
old "a"
new "a"
# renpy/common/_layout/classic_load_save.rpym:161
old "q"
new "q"
# : Translation updated at 2013-11-17 23:18
translate arabic strings:
# renpy/common/00action_file.rpy:587
old "Quick save complete."
new "تم الحفظ السريع بنجاح"
# : Translation updated at 2013-11-17 23:18
translate arabic strings:
# renpy/common/00gallery.rpy:521
old "Image [index] of [count] locked."
new "يوجد عدد صور [index] من أصل [count] مقفل"
# renpy/common/00gallery.rpy:539
old "prev"
new "السابق"
# renpy/common/00gallery.rpy:540
old "next"
new "التالي"
# renpy/common/00gallery.rpy:541
old "slideshow"
new "عرض الشرائح"
# renpy/common/00gallery.rpy:542
old "return"
new "العودة"
# : Translation updated at 2013-11-17 23:18
translate arabic strings:
# renpy/common/00layout.rpy:427
old "Are you sure you want to begin skipping?"
new "هل أنت متأكد من رغبتك في البدء بالتسريع؟"
# renpy/common/00layout.rpy:428
old "Are you sure you want to skip to the next choice?"
new "هل انت متأكد من رغبتك في التسريع حتى الخيار التالي؟"
# renpy/common/00layout.rpy:429
old "Are you sure you want to skip to unseen dialogue or the next choice?"
new "هل انت متأكد من رغبتك في تسريع الخيارات و الحوار الذي لم يسبق لك قرائته؟"
# : Translation updated at 2014-04-17 13:01
translate arabic strings:
# renpy/common/00console.rpy:179
old "%(version)s console, originally by Shiz, C, and delta.\n"
new ""
# renpy/common/00console.rpy:180
old "Press <esc> to exit console. Type help for help.\n"
new "إضغط زر الخروج لإغلاق لوحة التحكم, اكتب كلمة help للمساعدة"
# renpy/common/00console.rpy:184
old "Ren'Py script enabled."
new "لغة برمحة رينباي متاحه"
# renpy/common/00console.rpy:186
old "Ren'Py script disabled."
new "لغة برمجة رينباي غير متاحه"
# renpy/common/00console.rpy:392
old "help: show this help"
new "مساعده: عرض هذه المساعده"
# renpy/common/00console.rpy:397
old "commands:\n"
new "أوامر: \n"
# renpy/common/00console.rpy:407
old " <renpy script statement>: run the statement\n"
new "<renpy script statement>: عرض الأوامر\n"
# renpy/common/00console.rpy:409
old " <python expression or statement>: run the expression or statement"
new " <python expression or statement>: عرض التعبير او الأوامر"
# renpy/common/00console.rpy:417
old "clear: clear the console history"
new "clear: مسح تاريخ لوحة التحكم"
# renpy/common/00console.rpy:421
old "exit: exit the console"
new "exit: الخروج من لوحة التحكم"
# renpy/common/00console.rpy:429
old "load <slot>: loads the game from slot"
new "استرجاع <slot>: يقوم باسترجاع اللعب من نقطة الحفظ"
# renpy/common/00console.rpy:442
old "save <slot>: saves the game in slot"
new "حفظ <slot>: يقوم بحفظ اللعب في نقطة الحفظ"
# renpy/common/00console.rpy:453
old "reload: reloads the game, refreshing the scripts"
new "reload: يعيد تشغيل اللعبة مع عرض التغييرات في النص"
# renpy/common/00console.rpy:461
old "watch <expression>: watch a python expression"
new "مشاهده <expression>: يقوم بعرض تبيرات بايثون"
# renpy/common/00console.rpy:470
old "unwatch <expression>: stop watching an expression"
new "unwatch <expression>: يقوم بإيقاف تعبير بايثون"
# renpy/common/00console.rpy:478
old "unwatchall: stop watching all expressions"
new "unwatchall: يقوم بإيقاف كل تعبيرات بايثون"
# renpy/common/00console.rpy:484
old "jump <label>: jumps to label"
new "jump <label>: يقفز للعنوان"
# : Translation updated at 2014-04-17 13:01
translate arabic strings:
# renpy/common/00keymap.rpy:332
old "Autoreload"
new "إعادة التحميل تلقائياً"
# : Translation updated at 2014-04-17 13:01
translate arabic strings:
# renpy/common/_developer/developer.rpym:65
old "Developer Menu"
new "قائمة المبرمج"
# renpy/common/_developer/developer.rpym:67
old "Reload Game (Shift+R)"
new "إعادة تشغيل اللعبة (Shift+R)"
# renpy/common/_developer/developer.rpym:69
old "Console (Shift+O)"
new "لوحة التحكم (Shift+O)"
# renpy/common/_developer/developer.rpym:71
old "Variable Viewer"
new "مستعرض الأوامر"
# renpy/common/_developer/developer.rpym:73
old "Theme Test"
new "اختبار القوالب"
# renpy/common/_developer/developer.rpym:75
old "Image Location Picker"
new "مكان الصور المطلوبة"
# renpy/common/_developer/developer.rpym:77
old "Filename List"
new "قائمة اسماء الملفات"
# renpy/common/_developer/developer.rpym:81
old "Show Image Load Log"
new "عرض قائمة الصور "
# renpy/common/_developer/developer.rpym:84
old "Hide Image Load Log"
new "إخفاء قائمة الصور"
# renpy/common/_developer/developer.rpym:149
old "No variables have changed since the game started."
new "لم يتم تغيير اي من الأوامر منذ ان بدأت اللعبة"
# renpy/common/_developer/developer.rpym:152
old "Return to the developer menu"
new "العودة للوحة المبرمج"
# renpy/common/_developer/developer.rpym:272
old "{b}Missing Images{/b}"
new "{b}صور مفقودة{/b}"
# renpy/common/_developer/developer.rpym:424
old "Rectangle: %r"
new "مثلث: %r"
# renpy/common/_developer/developer.rpym:429
old "Mouse position: %r"
new "مكان المؤشر: %r"
# renpy/common/_developer/developer.rpym:431
old "Right-click or escape to quit."
new "إضغط بالزر الايمن او إضغط زر الخروح للإغلاق"
# renpy/common/_developer/developer.rpym:482
old "Done"
new "تم"
# : Translation updated at 2014-04-17 13:01
translate arabic strings:
# renpy/common/_developer/inspector.rpym:43
old "Displayable Inspector"
new "اختبار المستعرضات"
# renpy/common/_developer/inspector.rpym:49
old "Nothing to inspect."
new "لا يوجد شيء ليتم اختباره"
# renpy/common/_developer/inspector.rpym:58
old "Size"
new "حجم"
# renpy/common/_developer/inspector.rpym:63
old "Style"
new "مظهر"
# renpy/common/_developer/inspector.rpym:123
old "Inspecting Styles of [displayable_name!q]"
new "يتم اختبار المظهر الخاص بـ [displayable_name!q]"
old "Processed {b}[complete]{/b} of {b}[total]{/b} files."
new "تم انهاء {b}[complete]{/b} من عدد {b}[total]{/b} من الملفات."
# game/distribute.rpy:915
old "All packages have been built.\n\nDue to the presence of permission information, unpacking and repacking the Linux and Macintosh distributions on Windows is not supported."
new "تم الإنتهاء من تكوين رزمة البيانات لنشر اللعبة. بسبب اختلاف نظام الملفات في الأنظمة التشغيلية ماك و لينوكس, لا يمكن فك الضغط عن الرزمة الخاصة بتلك الأنظمة على نظام وندوز."
# : Translation updated at 2013-11-17 23:18
translate arabic strings:
# game/distribute.rpy:358
old "No packages are selected, so there's nothing to do."
new "لم يتم اختيار اي حزمة, لم يحصل اي شيء."
# : Translation updated at 2014-04-17 13:01
translate arabic strings:
# game/distribute.rpy:335
old "Building distributions failed:\n\nThe build.directory_name variable may not include the space, colon, or semicolon characters."
new "فشل بناء ملفات النشر. build.directory_name يجب أن لا يحتوي على مساحات فارغة, فواصل, او فواصل منقوطة في إسم المجلد "
old "{b}Recommended.{/b} A beta editor with an easy to use interface and features that aid in development, such as spell-checking. Editra currently lacks the IME support required for Chinese, Japanese, and Korean text input."
new "{b}نقترح.{/b} محرر نص له واجهة سهلة الاستعمال ويعين على كتابة النصوص البرمجية يفضل برنامج يحتوي على مدقق لغوي. Editraحالياً لا يدعم اللغات الأجنبية مثل اللغه الكورية و الصينية و اليابانية."
# game/editor.rpy:121
old "{b}Recommended.{/b} A beta editor with an easy to use interface and features that aid in development, such as spell-checking. Editra currently lacks the IME support required for Chinese, Japanese, and Korean text input. On Linux, Editra requires wxPython."
new "{b}نقترح.{/b} محرر نص له واجهة سهلة الاستعمال ويعين على كتابة النصوص البرمجية يفضل برنامج يحتوي على مدقق لغوي. Editraحالياً لا يدعم اللغات الأجنبية مثل اللغه الكورية و الصينية و اليابانية. على نظام لينوكس, Editra يحتاج wxPython."
# game/editor.rpy:137
old "The may have occured because wxPython is not installed on this system."
new "قد يكون السبب ان wxPython غير موجود على هذا الجهاز."
# game/editor.rpy:144
old "Up to 22 MB download required."
new "مطلوب تحميل ملف بحجم 22 ميغا بايت."
# game/editor.rpy:157
old "1.8 MB download required."
new "مطلوب تحميل ملف بحجم 1.8 ميغا بايت."
# game/editor.rpy:158
old "This may have occured because Java is not installed on this system."
new "قد يكون السبب ان الجافا غير موجوده على هذا الجهاز."
# game/editor.rpy:327
old "An exception occured while launching the text editor:\n[exception!q]"
new "حصل استثناء اثناء فتح المحرر: \n[exception!q]"
# game/editor.rpy:378
old "Select Editor"
new "الرجاء اختيار المحرر"
# game/editor.rpy:393
old "A text editor is the program you'll use to edit Ren'Py script files. Here, you can select the editor Ren'Py will use. If not already present, the editor will be automatically downloaded and installed."
new "محرر النصوص هو برنامج يساعدك على تعديل ملفات رينباي البرمجية والحوار. هنا, يمكنك اختيار المحرر الذي سيستعلمه رينباي. إذا لم يكن لديك مسبقاً, سيتم تحميله و تنصيبه بشكل اوتوماتيكي."
# game/editor.rpy:415
old "Cancel"
new "إلغاء الامر"
# Translation updated at 2013-11-17 23:18
translate arabic strings:
# game/editor.rpy:137
old "This may have occured because wxPython is not installed on this system."
new "قد يكون سبب ذلك ان wxPython غير موجود في نظام التشغيل لديك"
# game/editor.rpy:155
old "A mature editor that requires Java."
new "محرر متخصص يستعمل لغة جافا"
# game/editor.rpy:164
old "Invokes the editor your operating system has associated with .rpy files."
new "يقوم بفتح البرنامج المسؤول عن تحرير ملفات .rpy في نظامك التشغيلي"
old "Please select a template to use for your new project. Ren'Py ships with a default template that creates an English-language game with standard screens."
new "الرجاء اختيار التصميم الذي ترغبه لمشروعك الجديد. رينباي يأتي بعدة تصاميم قياسية يمكنك التعديل عليها لاحقاً."
# game/new_project.rpy:55
old "PROJECT NAME"
new "اسم المشروع"
# game/new_project.rpy:56
old "Please enter the name of your project:"
new "الرجاء اختيار اسم لمشروعك الجديد"
# game/new_project.rpy:62
old "The project name may not be empty."
new "لا يمكن ان يكون اسم المشروع فارغاً"
# game/new_project.rpy:67
old "[project_name!q] already exists. Please choose a different project name."
new "الاسم [project_name!q] يوجد مسبقاً, الرجاء اختيار اسم مختلف."
# game/new_project.rpy:70
old "[project_dir!q] already exists. Please choose a different project name."
new "[project_dir!q] يوجد مسبقاً, الرجاء اختيار اسم مختلف."
# : Translation updated at 2013-11-17 23:18
translate arabic strings:
# game/new_project.rpy:40
old "Please select a template to use for your new project. The template sets the default font and the user interface language. If your language is not supported, choose 'english'."
new "الرجاء اختيار القالب المطلوب للمشروع الجديد. هذه القوالب تقوم بتجهيز اتجاه النص و اللغه المستخدمة في الواجهة لتسهل عملية البدء. إذا لم تكن لغتك مدعومة الرجاء اختيار اللغة الانجليزية."
# : Translation updated at 2014-04-17 13:01
translate arabic strings:
# game/new_project.rpy:71
old "The projects directory could not be set. Giving up."
old "Please choose the projects directory using the directory chooser.\n{b}The directory chooser may have opened behind this window.{/b}"
new "الرجاء اختيار نسق المشاريع من الصفحة الخاصة بذلك. \n{b}قد تكون النافذة ظهرت خلف هذه النافذة.{/b}"
# game/project.rpy:485
old "This launcher will scan for projects in this directory, will create new projects in this directory, and will place built projects into this directory."
new "سيقوم البرنامج بفحص المجلد هذا لإيجاد المشاريع السابقة, أو ليضع المشاريع الجديده فيه, و ايضاً لوضع المشاريع المنتهيه عند تجهيزها للنشر."
# game/project.rpy:525
old "Ren'Py was unable to run python with tkinter to choose the projects directory."
new "رينباي لم يستطع تشغيل برمجيات بايثون للبحث عن مجلد المشاريع."
# game/project.rpy:529
old "Ren'Py has set the projects directory to:"
new "رينباي قام بتحديد مجلد المشاريع إلى المكان التالي:"
# : Translation updated at 2014-04-17 13:01
translate arabic strings:
# game/project.rpy:48
old "After making changes to the script, press shift+R to reload your game."
new "عند إجراء أي تغييرات في ملف الحوار, يمكنك ضغط shift+R لترى التغييرات داخل اللعبة"
# game/project.rpy:49
old "Press shift+O (the letter) to access the console."
new "إضغط shift+O للدخول على لوحة التحكم"
# game/project.rpy:50
old "Press shift+D to access the developer menu."
new "إضغط shift+D للدخول على لوحة تحكم المبرمج"
# game/project.rpy:219
old "Launching the project failed."
new "لم تنجح محاولة إقلاع المشروع"
# game/project.rpy:219
old "Please ensure that your project launches normally before running this command."
new "الرجاء التأكد من سلامة إقلاع المشروع قبل تشغيل هذا الأمر البرمجي"
# game/project.rpy:516
old "Launching"
new "جاري الإقلاع"
# game/project.rpy:585
old "Ren'Py was unable to run python with tkinter to choose the projects directory. Please install the python-tk or tkinter package."
new "رينباي لم يتمكن من تشغيل بايثون مع tkinter لكي يختار مجلد المشاريع, الرجاء تنصيب Python-tk او tkinter"
# Translation updated at 2014-09-30 23:01
translate arabic strings:
# game/project.rpy:47
old "Have you backed up your projects recently?"
new "هل قمت بعمل نسخة احتياطية من مشاريعك مؤخراً؟"
old "Enter the name of the script file to create."
new "Entrez le nom du fichier de script à créer."
# game/add_file.rpy:10
old "The filename must have the .rpy extension."
new "Le fichier doit avoir l'extension .rpy."
# game/add_file.rpy:18
old "The file already exists."
new "Le fichier éxiste déjà."
# game/add_file.rpy:21
old "# Ren'Py automatically loads all script files ending with .rpy. To use this\n# file, define a label and jump to it from another file.\n"
new "Ren'Py charge automatiquement tous les fichiers de script finissant par .rpy. Pour utiliser ce ficher\n#, définissez un label et faites un «jump» vers lui depuis un autre fichier.\n"
old "To build Android packages, please download RAPT (from {a=http://www.renpy.org/dl/android}here{/a}), unzip it, and place it into the Ren'Py directory. Then restart the Ren'Py launcher."
new "Pour construire les paquets Android, téléchargez RAPT (depuis {a=http://www.renpy.org/dl/android}here{/a}), dézippé le, et placez le dans le répertoire de Ren'Py. Puis, redémarrez Ren'Py."
# game/android.rpy:13
old "RAPT has been installed, but you'll need to install the Android SDK before you can build Android packages. Choose Install SDK to do this."
new "RAPT a été installé, mais vous devez installer le kit de développement Android pour pouvoir construire les paquets Android. Choisissez \"installer le kit de développement et créer les clés\" pour cela"
# game/android.rpy:14
old "RAPT has been installed, but a key hasn't been configured. Please create a new key, or restore android.keystore."
new "RAPT a été installé, mais aucune clé n'a été configurée. Créez une nouvelle clé, ou restaurez android.keystore."
# game/android.rpy:15
old "The current project has not been configured. Use \"Configure\" to configure it before building."
new "Le projet courant n'a pas été configuré. Choisissez \"Configurer\' pour effectuer la configuration."
# game/android.rpy:16
old "Choose \"Build\" to build the current project, or attach an Android device and choose \"Build & Install\" to build and install it on the device."
new "Choisissez \"Construire\" pour construire le projet courant, ou connecté un appareil Android et choisissez \"Construire et Installer\" pour l'installer sur l'appareil."
# game/android.rpy:18
old "Attempts to emulate an Android phone.\n\nTouch input is emulated through the mouse, but only when the button is held down. Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "Tentative d'émulation d'un téléphone Android.\n\nLe touché est émulé via la souris, mails uniquement lorsque le bouton est pressé. La barre d'espace correspond au bouton menu, et la touche PageUp correspond au bouton retour."
# game/android.rpy:19
old "Attempts to emulate an Android tablet.\n\nTouch input is emulated through the mouse, but only when the button is held down. Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "Tentative d'émulation d'une tablette Android.\n\nLe touché est émulé via la souris, mails uniquement lorsque le bouton est pressé. La barre d'espace correspond au bouton menu, et la touche PageUp correspond au bouton retour."
# game/android.rpy:20
old "Attempts to emulate an OUYA console.\n\nController input is mapped to the arrow keys, Enter is mapped to the select button, Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "Tentative d'émulation d'une console OUYA.\n\nLe pad est émulé via les flèches du clavier. La touche Entrée correspond au bouton select, la barre d'espace au bouton menu, et la touche PageUp correspond au bouton retour."
# game/android.rpy:22
old "Downloads and installs the Android SDK and supporting packages. Optionally, generates the keys required to sign the package."
new "Télécharge et installe le kit de développement Android et les paquets supportés. Optionnellement, génère les clés requises pour signer le paquet."
# game/android.rpy:23
old "Configures the package name, version, and other information about this project."
new "Configure le nom du packet, sa version et d'autres informations à propos de ce projet."
# game/android.rpy:24
old "Opens the file containing the Google Play keys in the editor.\n\nThis is only needed if the application is using an expansion APK. Read the documentation for more details."
new "Ouvre le fichier contenant les clés Google Play dans l'éditeur.\n\nCela est nécessaire uniquement si l'application utilise une expansion APK. Référez-vous à la documentation pour plus d'informations."
# game/android.rpy:25
old "Builds the Android package."
new "Construire le paquet Android."
# game/android.rpy:26
old "Builds the Android package, and installs it on an Android device connected to your computer."
new "Construire le paquet Android, et l'installer sur l'appareil Android connecté à votre ordinateur."
# game/android.rpy:142
old "{a=%s}%s{/a}"
new "{a=%s}%s{/a}"
# game/android.rpy:361
old "Android: [project.current.name!q]"
new "Android: [project.current.name!q]"
# game/android.rpy:381
old "Emulation:"
new "Émulateur:"
# game/android.rpy:389
old "Phone"
new "Téléphone"
# game/android.rpy:393
old "Tablet"
new "Tablette"
# game/android.rpy:397
old "Television / OUYA"
new "Télévision / OUYA"
# game/android.rpy:409
old "Build:"
new "Construire:"
# game/android.rpy:417
old "Install SDK & Create Keys"
new "Installer le kit de développement et créer les clés"
# game/android.rpy:421
old "Configure"
new "Configurer"
# game/android.rpy:425
old "Build Package"
new "Construire le paquet"
# game/android.rpy:429
old "Build & Install"
new "Construire et installer"
# game/android.rpy:13
old "A 32-bit Java Development Kit is required to build Android packages on Windows. The JDK is different from the JRE, so it's possible you have Java without having the JDK.\n\nPlease {a=http://www.oracle.com/technetwork/java/javase/downloads/index.html}download and install the JDK{/a}, then restart the Ren'Py launcher."
new "Un Kit de Développement Java (JDK) 32 bits est nécessaire pour construire les paquets pour Android depuis Windows. Le JDK n'est pas la même chose que le JRE, il est possible que Java soit installé sur votre machine sans le JDK.\n\n{a=http://www.oracle.com/technetwork/java/javase/downloads/index.html}Téléchargez et installez le JDK{/a}, puis relancer le lanceur Ren'Py."
new "Êtes-vous sûr de vouloir supprimer cette sauvegarde ?"
# renpy/common/00layout.rpy:423
old "Are you sure you want to overwrite your save?"
new "Êtes-vous sûr de vouloir écraser cette sauvegarde ?"
# renpy/common/00layout.rpy:424
old "Loading will lose unsaved progress.\nAre you sure you want to do this?"
new "En effectuant ce chargement, vous perderez votre avancement non sauvegardé.\nÊtes-vous sûr de vouloire faire ça ?"
# renpy/common/00layout.rpy:425
old "Are you sure you want to quit?"
new "Êtes-vous sûr de vouloir quitter ?"
# renpy/common/00layout.rpy:426
old "Are you sure you want to return to the main menu?\nThis will lose unsaved progress."
new "Êtes-vous sûr de vouloir retourner au menu principal ?\nVous perdrez votre avancement non sauvegardé."
# renpy/common/00keymap.rpy:167
old "Saved screenshot as %s."
new "La capture d'écran a été enregistrée en tant que %s"
# renpy/common/00gltest.rpy:50
old "Graphics Acceleration"
new "Accélération graphique"
# renpy/common/00gltest.rpy:54
old "Automatically Choose"
new "Choix automatique"
# renpy/common/00gltest.rpy:59
old "Force Angle/DirectX Renderer"
new "Forcer le rendu Angle/DirectX"
# renpy/common/00gltest.rpy:63
old "Force OpenGL Renderer"
new "Forcer le rendu OpenGL"
# renpy/common/00gltest.rpy:67
old "Force Software Renderer"
new "Forcer le rendu logiciel"
# renpy/common/00gltest.rpy:73
old "Changes will take effect the next time this program is run."
new "Les changement seront pris en compte au prochin démarrage du programme."
# renpy/common/00gltest.rpy:77
old "Quit"
new "Quitter"
# renpy/common/00gltest.rpy:82
old "Return"
new "Retour"
# renpy/common/00gltest.rpy:112
old "Performance Warning"
new "Avertissement sur les performances"
# renpy/common/00gltest.rpy:117
old "This computer is using software rendering."
new "Cet ordinateur utilise le rendu logiciel."
# renpy/common/00gltest.rpy:119
old "This computer is not using shaders."
new "Cet ordinateur n'utilise pas les shaders."
# renpy/common/00gltest.rpy:121
old "This computer is displaying graphics slowly."
new "Cet ordinateur affiche lentement les graphismes."
# renpy/common/00gltest.rpy:123
old "This computer has a problem displaying graphics: [problem]."
new "Cet ordinateur rencontre des difficultés à afficher les graphismes: [problem]."
# renpy/common/00gltest.rpy:128
old "Its graphics drivers may be out of date or not operating correctly. This can lead to slow or incorrect graphics display. Updating DirectX could fix this problem."
new "Les pilotes graphiques ne semblent pas à jour ou dysfonctionnent. Cela peut entraîner des ralentissements ou de mauvais affichages. Mettre à jour DirectX pourraît régler ce problème."
# renpy/common/00gltest.rpy:130
old "Its graphics drivers may be out of date or not operating correctly. This can lead to slow or incorrect graphics display."
new "Les pilotes graphiques ne semblent pas à jour ou dysfonctionnent. Cela peut entraîner des ralentissements ou de mauvais affichages."
# renpy/common/00gltest.rpy:135
old "Update DirectX"
new "Mettre à jour DirectX"
# renpy/common/00gltest.rpy:141
old "Continue, Show this warning again"
new "Continer, Afficher cet avertissement la prochaine fois."
# renpy/common/00gltest.rpy:145
old "Continue, Don't show warning again"
new "Continer, Ne plus afficher cet avertissement."
# renpy/common/00gltest.rpy:171
old "Updating DirectX."
new "Mettre à jour de DirectX en cours"
# renpy/common/00gltest.rpy:175
old "DirectX web setup has been started. It may start minimized in the taskbar. Please follow the prompts to install DirectX."
new "La mise à jour de DirectX a débutée. Elle est sans doute minimisée dans la bare de tâche. Merci de suivre les instructions pour installer DirectX."
# renpy/common/00gltest.rpy:179
old "{b}Note:{/b} Microsoft's DirectX web setup program will, by default, install the Bing toolbar. If you do not want this toolbar, uncheck the appropriate box."
new "{b}Note:{/b} le programme d'installation de Microsoft's DirectX va, par defaut, installer la barre d'outils Bing. Si vous ne voulez pas de cette barre, décochez la case appropriée."
# renpy/common/00gltest.rpy:183
old "When setup finishes, please click below to restart this program."
new "Lorsque l'instllation sera terminée, cliquez ci-dessous pour redémarrer ce programme."
# renpy/common/00gltest.rpy:185
old "Restart"
new "Redémarrer"
# renpy/common/_errorhandling.rpym:408
old "An exception has occurred."
new "Une exception a été levée."
# renpy/common/_errorhandling.rpym:434
old "Rollback"
new "Revenir en arrière"
# renpy/common/_errorhandling.rpym:436
old "Attempts a roll back to a prior time, allowing you to save or choose a different choice."
new "Tenter de revenir en arrière, vous permet de sauvegarder ou de faire un autre choix."
# renpy/common/_errorhandling.rpym:439
old "Ignore"
new "Ignorer"
# renpy/common/_errorhandling.rpym:441
old "Ignores the exception, allowing you to continue. This often leads to additional errors."
new "Ignorer l'exception vous permet de continuer. Cela entraîne généralement des erreurs additionelles."
# renpy/common/_errorhandling.rpym:444
old "Reload"
new "Recharger"
# renpy/common/_errorhandling.rpym:446
old "Reloads the game from disk, saving and restoring game state if possible."
new "Recharger le jeu depuis le disque dur and tenter de restaurer le jeu dans l'état actuel."
# renpy/common/_errorhandling.rpym:448
old "Open Traceback"
new "Ouvrir la pile d'appel"
# renpy/common/_errorhandling.rpym:450
old "Opens the traceback.txt file in a text editor."
new "Ouvrir traceback.txt dans un éditeur de texte."
# renpy/common/_errorhandling.rpym:456
old "Quits the game."
new "Quitter le jeu."
# renpy/common/_errorhandling.rpym:483
old "Parsing the script failed."
new "L'analyse du script a échouée."
# renpy/common/_errorhandling.rpym:510
old "Open Parse Errors"
new "Ouvrir les erreurs d'analyse."
# renpy/common/_errorhandling.rpym:512
old "Opens the errors.txt file in a text editor."
new "Ouvrir errors.txt dans un éditeur de texte."
# renpy/common/00action_file.rpy:118
old "%b %d, %H:%M"
new "%b %d, %H:%M"
# renpy/common/_compat/gamemenu.rpym:337
old "Previous"
new "Précédent"
# renpy/common/_compat/gamemenu.rpym:344
old "Next"
new "Suivant"
# renpy/common/00library.rpy:77
old "Skip Mode"
new "Mode rapide"
# renpy/common/00library.rpy:80
old "Fast Skip Mode"
new "Mode très rapide"
# renpy/common/00gallery.rpy:521
old "Image [index] of [count] locked."
new "Image [index] sur [count] verrouillée."
# renpy/common/00gallery.rpy:539
old "prev"
new "précédent"
# renpy/common/00gallery.rpy:540
old "next"
new "suivant"
# renpy/common/00gallery.rpy:541
old "slideshow"
new "diaporama"
# renpy/common/00gallery.rpy:542
old "return"
new "retour"
# renpy/common/00layout.rpy:427
old "Are you sure you want to begin skipping?"
new "Êtes-vous sûr de vouloir commencer à sauter certaines étapes ?"
# renpy/common/00layout.rpy:428
old "Are you sure you want to skip to the next choice?"
new "Êtes-vous sûr de vouloir sauter le prochain choix ?"
# renpy/common/00layout.rpy:429
old "Are you sure you want to skip to unseen dialogue or the next choice?"
new "Êtes-vous sûr de vouloir sauter des dialogues non lus or le prochain choix ?"
new "Création du fichier de mise à jour zsync [variant]."
# game/distribute.rpy:854
old "Processed {b}[complete]{/b} of {b}[total]{/b} files."
new "Traitement du fichier {b}[complete]{/b} sur {b}[total]{/b}."
# game/distribute.rpy:915
old "All packages have been built.\n\nDue to the presence of permission information, unpacking and repacking the Linux and Macintosh distributions on Windows is not supported."
new "Tous les paquets ont été contruits.\n\nDu fait de la présence des systèmes de permissions, il n'est pas possible de reconstruire les paquets construits sur GNU-Linux ou Mac OS sur Windows."
# game/distribute.rpy:358
old "No packages are selected, so there's nothing to do."
new "Aucun paquet sélectionné, il n'y a donc rien à faire."
old "{b}Recommended.{/b} A beta editor with an easy to use interface and features that aid in development, such as spell-checking. Editra currently lacks the IME support required for Chinese, Japanese, and Korean text input."
new "{b}Recommendé.{/b} Un éditeur en version bêta avec une interface simple et des fonctionnalités d'assistance au développement. Editra manque pour le moment du support pour les textes en chinois, japonais et coréen."
# game/editor.rpy:121
old "{b}Recommended.{/b} A beta editor with an easy to use interface and features that aid in development, such as spell-checking. Editra currently lacks the IME support required for Chinese, Japanese, and Korean text input. On Linux, Editra requires wxPython."
new "{b}Recommendé.{/b} Un éditeur en version bêta avec une interface simple et des fonctionnalités d'assistance au développement. Editra manque pour le moment du support pour les textes en chinois, japonais et coréen. Sur GNU-Linux, Editra nécessite wxPython."
# game/editor.rpy:137
old "The may have occured because wxPython is not installed on this system."
new "Cela est sans doute arrivé car wxPython n'est pas installé sur ce système."
# game/editor.rpy:144
old "Up to 22 MB download required."
new "Jusqu'à 22 MB de téléchargement requis."
# game/editor.rpy:157
old "1.8 MB download required."
new "1.8 MB de réléchargement requis."
# game/editor.rpy:158
old "This may have occured because Java is not installed on this system."
new "Cela est sans doute arrivé car Java n'est pas installé sur ce système."
# game/editor.rpy:327
old "An exception occured while launching the text editor:\n[exception!q]"
new "Une exception a été levée lors du lancement de l'édieteur de texte :\n[exception!q]"
# game/editor.rpy:378
old "Select Editor"
new "Sélectionnez un éditeur"
# game/editor.rpy:393
old "A text editor is the program you'll use to edit Ren'Py script files. Here, you can select the editor Ren'Py will use. If not already present, the editor will be automatically downloaded and installed."
new "Un éditeur de texte est un logiciel que vous utilisez pour éditer les fichiers de script Ren'Py. Vous pouvez choisir l'édteur que Ren'Py utilise. Si ce n'est pas déjà le cas, l'éditeur sera automatiquement téléchargé et installé."
# game/editor.rpy:415
old "Cancel"
new "Annuler"
# game/editor.rpy:137
old "This may have occured because wxPython is not installed on this system."
new "Cela est sans doute dû au fait que wxPython n'est pas installé sur votre système."
# game/editor.rpy:155
old "A mature editor that requires Java."
new "Un éditeur éprouvé nécessitant Java."
# game/editor.rpy:164
old "Invokes the editor your operating system has associated with .rpy files."
new "Lance l'éditeur associé par votre systèmes aux fichiers .rpy."
# game/editor.rpy:180
old "Prevents Ren'Py from opening a text editor."
new "Empêche Ren'Py d'ouvrir un éditeur de texte."
old "Please select a template to use for your new project. Ren'Py ships with a default template that creates an English-language game with standard screens."
new "Merci de sélectioner un patron à utiliser pour votre nouveau projet. Ren'Py est livré avec un patron par défaut qui créé un jeu en anglais avec des écrans standards."
# game/new_project.rpy:55
old "PROJECT NAME"
new "NOM DU PROJET"
# game/new_project.rpy:56
old "Please enter the name of your project:"
new "Entrez le nom de votre projet:"
# game/new_project.rpy:62
old "The project name may not be empty."
new "Le nom du projet ne doit pas être vide."
# game/new_project.rpy:67
old "[project_name!q] already exists. Please choose a different project name."
new "Le projet [project_name!q] éxiste déjà. Choisissez un nom de projet différend."
# game/new_project.rpy:70
old "[project_dir!q] already exists. Please choose a different project name."
new "Le projet [project_name!q] éxiste déjà. Choisissez un nom de projet différend."
# game/new_project.rpy:40
old "Please select a template to use for your new project. The template sets the default font and the user interface language. If your language is not supported, choose 'english'."
new "Sélectionnez un gabarit pour votre nouveau projet. Le gabarit définit la police par défaut, ainsi que la langue de l'interface. Si votre langue n'est pas supportée, sélectionnez 'english'."
old "Please choose the projects directory using the directory chooser.\n{b}The directory chooser may have opened behind this window.{/b}"
new "Choisissez le répertoire des projets avec le sélecteur de fichier.\n{b}Il se peut que le sélecteur de fichier s'ouvre derière cette fenêtre.{/b}"
# game/project.rpy:485
old "This launcher will scan for projects in this directory, will create new projects in this directory, and will place built projects into this directory."
new "Ce lanceur va scanner ce répertoire pour trouver des projets éxistants, créra les nouveaux projets dans ce répertoire, et placera les projets construits dans ce répertoire."
# game/project.rpy:525
old "Ren'Py was unable to run python with tkinter to choose the projects directory."
new "Ren'Py n'a pas pu lancer python avec le module tkinker pout choisir le répertoire des projets."
# game/project.rpy:529
old "Ren'Py has set the projects directory to:"
new "Le répertoire des projets vient d'être établit:"
old "The update channel controls the version of Ren'Py the updater will download. Please select an update channel:"
new "Choisissez une version."
# game/updater.rpy:70
old "Release"
new "version courrante."
# game/updater.rpy:76
old "{b}Recommended.{/b} The version of Ren'Py that should be used in all newly-released games."
new "{b}Recommendé.{/b} La version de Ren'Py qui devrait être utilisée pour créer de nouveaux jeux."
# game/updater.rpy:81
old "Prerelease"
new "Version de test"
# game/updater.rpy:87
old "A preview of the next version of Ren'Py that can be used for testing and taking advantage of new features, but not for final releases of games."
new "Un aperçu de la prochaine version de Ren'Py qui peut être utilisée pour faire des tests et profiter de toutes nouvelles fonctionnalitées, mais par pour créer de nouveaux jeux."
# game/updater.rpy:93
old "Experimental"
new "Expérimental"
# game/updater.rpy:99
old "Experimental versions of Ren'Py. You shouldn't select this channel unless asked by a Ren'Py developer."
new "Version expérimentale de Ren'Py. Vous ne devriez pas choisir cette version, à moins qu'un développeur de Ren'Py ne vous y invite."
# game/updater.rpy:119
old "An error has occured:"
new "Une erreur est apparue."
# game/updater.rpy:121
old "Checking for updates."
new "Vérifier les mises à jour."
# game/updater.rpy:123
old "Ren'Py is up to date."
new "Ren'Py est à jour."
# game/updater.rpy:125
old "[u.version] is now available. Do you want to install it?"
new "La version [u.version] est disponible. Voulez-vous l'installer ?"
# game/updater.rpy:127
old "Preparing to download the update."
new "Préparation du téléchargement de la mise à jour."
# game/updater.rpy:129
old "Downloading the update."
new "Téléchargement de la mise à jour."
# game/updater.rpy:131
old "Unpacking the update."
new "Dépaquetage de la mise à jour."
# game/updater.rpy:133
old "Finishing up."
new "Dernier réglages."
# game/updater.rpy:135
old "The update has been installed. Ren'Py will restart."
new "La mise à jour a bien été effectuée. Ren'Py va redémarrer."
old "Enter the name of the script file to create."
new "Geben Sie den Namen der Script-Datei ein, um sie zu erstellen."
# game/add_file.rpy:10
old "The filename must have the .rpy extension."
new "Der Dateiname muss die Endung .rpy haben."
# game/add_file.rpy:18
old "The file already exists."
new "Die Datei existiert bereits."
# game/add_file.rpy:21
old "# Ren'Py automatically loads all script files ending with .rpy. To use this\n# file, define a label and jump to it from another file.\n"
new "# Ren’Py lädt automatisch alle Skript-Dateien, die auf .rpy enden. Um diese\n# Datei zu verwenden, setzen sie ein Label und springen sie aus einer anderen Datei dorthin.\n"
old "To build Android packages, please download RAPT (from {a=http://www.renpy.org/dl/android}here{/a}), unzip it, and place it into the Ren'Py directory. Then restart the Ren'Py launcher."
new "Um eine Android-Datei zu erstellen, laden Sie bitte RAPT ({a=http://www.renpy.org/dl/android}hier{/a}) herunter, entpacken Sie es und platzieren Sie es im Ren’Py Verzeichnis. Starten Sie dann bitte Ren’Py neu."
# game/android.rpy:13
old "RAPT has been installed, but you'll need to install the Android SDK before you can build Android packages. Choose Install SDK to do this."
new "RAPT wurde installiert, aber Sie müssen das Android-SDK installieren, bevor Sie Android-Dateien erstellen können. Wählen Sie „SDK Installieren“, um dies zu tun."
# game/android.rpy:14
old "RAPT has been installed, but a key hasn't been configured. Please create a new key, or restore android.keystore."
new "RAPT wurde installiert, aber ein Key wurde nicht eingestellt. Bitte erstellen Sie einen neuen Key oder stellen Sie android.keystore wieder her."
# game/android.rpy:15
old "The current project has not been configured. Use \"Configure\" to configure it before building."
new "Das aktuelle Projekt wurde nicht eingestellt. Verwenden Sie „Einstellen“, um es vor der Erstellung anzupassen."
# game/android.rpy:16
old "Choose \"Build\" to build the current project, or attach an Android device and choose \"Build & Install\" to build and install it on the device."
new "Wählen Sie „Erstellen“, um das aktuelle Projekt zu erstellen oder schließen Sie ein Android-Gerät an und wählen Sie „Erstellen und installieren“, um es zu erstellen und auf dem Gerät zu installieren."
# game/android.rpy:18
old "Attempts to emulate an Android phone.\n\nTouch input is emulated through the mouse, but only when the button is held down. Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "Emuliert ein Android-Handy.\n\nDie Berührungseingabe wird mithilfe der Maus emuliert, aber nur, wenn die Schaltfläche gedrückt wird. „Escape“ fungiert als Menüschaltfläche und „Bild rauf“ als „Zurück-Schaltfläche“."
# game/android.rpy:19
old "Attempts to emulate an Android tablet.\n\nTouch input is emulated through the mouse, but only when the button is held down. Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "Emuliert ein Android-Tablet.\n\nDie Berührungseingabe wird mithilfe der Maus emuliert, aber nur, wenn die Schaltfläche gedrückt wird. „Escape“ fungiert als Menüschaltfläche und „Bild rauf“ als „Zurück-Schaltfläche“."
# game/android.rpy:20
old "Attempts to emulate an OUYA console.\n\nController input is mapped to the arrow keys, Enter is mapped to the select button, Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "Emuliert eine OUYA-Konsole.\n\nDie Contollereingabe wird mithilfe der Pfeiltasten emuliert, „Enter“ fungiert als Auswahlschaltfläche, „Escape“ als Menüschaltfläche und „Bild rauf“ als „Zurück-Schaltfläche“."
# game/android.rpy:22
old "Downloads and installs the Android SDK and supporting packages. Optionally, generates the keys required to sign the package."
new "Lädt das Android SDK herunter und installiert es. Generiert optional die Keys, die für die Authentifizierung der Datei benötigt werden."
# game/android.rpy:23
old "Configures the package name, version, and other information about this project."
new "Stellt Dateinamen, Version und andere Informationen über dieses Projekt ein."
# game/android.rpy:24
old "Opens the file containing the Google Play keys in the editor.\n\nThis is only needed if the application is using an expansion APK. Read the documentation for more details."
new "Öffnet die Datei mit den Google-Play-Keys im Editor.\n\nDies ist nur nötig, wenn die Anwendung ein Expansion-APK verwendet. Lesen Sie die Dokumentation für weitere Details."
# game/android.rpy:25
old "Builds the Android package."
new "Erstellt die Android-Datei."
# game/android.rpy:26
old "Builds the Android package, and installs it on an Android device connected to your computer."
new "Erstellt die Android-Datei und installiert es auf ein Android-Gerät, das mit Ihrem Computer verbunden ist."
# game/android.rpy:142
old "{a=%s}%s{/a}"
new "{a=%s}%s{/a}"
# game/android.rpy:361
old "Android: [project.current.name!q]"
new "Android: [project.current.name!q]"
# game/android.rpy:381
old "Emulation:"
new "Emulation:"
# game/android.rpy:389
old "Phone"
new "Handy"
# game/android.rpy:393
old "Tablet"
new "Tablet"
# game/android.rpy:397
old "Television / OUYA"
new "Fernseher / OUYA"
# game/android.rpy:409
old "Build:"
new "Erstellen:"
# game/android.rpy:417
old "Install SDK & Create Keys"
new "SDK installieren und Keys erstellen"
# game/android.rpy:421
old "Configure"
new "Einstellen"
# game/android.rpy:425
old "Build Package"
new "Datei erstellen"
# game/android.rpy:429
old "Build & Install"
new "Erstellen und installieren"
translate german strings:
# game/android.rpy:30
old "To build Android packages, please download RAPT, unzip it, and place it into the Ren'Py directory. Then restart the Ren'Py launcher."
new "Um eine Android-Datei zu erstellen, laden Sie bitte RAPT herunter, entpacken Sie es und platzieren Sie es im Ren’Py Verzeichnis. Starten Sie dann bitte Ren’Py neu."
# game/android.rpy:31
old "A 32-bit Java Development Kit is required to build Android packages on Windows. The JDK is different from the JRE, so it's possible you have Java without having the JDK.\n\nPlease {a=http://www.oracle.com/technetwork/java/javase/downloads/index.html}download and install the JDK{/a}, then restart the Ren'Py launcher."
new "Ein 32-bit Java-Development-Kit wird benötigt, um Android-Packages auf Windows zu erstellen. Das JDK unterscheidet sich vom JRE, daher ist es möglich, dass Sie Java ohne das JDK installiert haben.\n\nBitte {a=http://www.oracle.com/technetwork/java/javase/downloads/index.html}laden Sie das JDK herunter und installieren Sie es{/a}, dann starten Sie den Ren’Py-Launcher neu."
# game/android.rpy:39
old "Attempts to emulate a televison-based Android console, like the OUYA or Fire TV.\n\nController input is mapped to the arrow keys, Enter is mapped to the select button, Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "Emuliert eine Fernseher-Android-Konsole wie die OUYA oder Fire TV.\n\nDie Contollereingabe wird mithilfe der Pfeiltasten emuliert, „Enter“ fungiert als Auswahlschaltfläche, „Escape“ als Menüschaltfläche und „Bild rauf“ als „Zurück-Schaltfläche“."
# game/android.rpy:47
old "Connects to an Android device running ADB in TCP/IP mode."
new "Verbindet mit einem Android-Gerät, das auf ADB im TCP/IP-Modus läuft."
# game/android.rpy:48
old "Disconnects from an Android device running ADB in TCP/IP mode."
new "Trennt Verbindung von einem Android-Gerät, das auf ADB im TCP/IP-Modus läuft."
# game/android.rpy:516
old "Other:"
new "Anderes:"
# game/android.rpy:524
old "Remote ADB Connect"
new "Remote-ADB verbinden"
# game/android.rpy:528
old "Remote ADB Disconnect"
new "Remote-ADB trennen"
# game/android.rpy:561
old "Before packaging Android apps, you'll need to download RAPT, the Ren'Py Android Packaging Tool. Would you like to download RAPT now?"
new "Bevor Sie Android-Apps erstellen können, müssen Sie RAPT herunterladen, das Ren’Py-Android-Packaging-Tool. Möchten Sie RAPT jetzt herunterladen?"
# game/android.rpy:608
old "Remote ADB Address"
new "Remote-ADB-Adresse"
# game/android.rpy:609
old "Please enter the IP address and port number to connect to, in the form \"192.168.1.143:5555\". Consult your device's documentation to determine if it supports remote ADB, and if so, the address and port to use."
new "Bitte geben Sie die IP-Adresse und die Port-Nummer zum Verbinden ein, Beispiel: „192.168.1.143:5555“. Schauen Sie im Handbuch ihres Geräts nach, um festzustellen, ob es Remote-ADB unterstützt, und wenn ja, schauen Sie die Adresse und den Port nach."
# game/android.rpy:619
old "Invalid remote ADB address"
new "Ungültige Remote-ADB-Adresse"
# game/android.rpy:619
old "The address must contain one exactly one ':'."
old "Changes will take effect the next time this program is run."
new "Die Änderungen werden beim nächsten Neustart des Programms übernommen."
# renpy/common/00gltest.rpy:82
old "Return"
new "Zurück"
# renpy/common/00gltest.rpy:112
old "Performance Warning"
new "Performance Warnung"
# renpy/common/00gltest.rpy:117
old "This computer is using software rendering."
new "Dieser Computer verwendet Software-Darstellung."
# renpy/common/00gltest.rpy:119
old "This computer is not using shaders."
new "Dieser Computer verwendet keine Shader."
# renpy/common/00gltest.rpy:121
old "This computer is displaying graphics slowly."
new "Dieser Computer zeigt Grafiken langsam an."
# renpy/common/00gltest.rpy:123
old "This computer has a problem displaying graphics: [problem]."
new "Dieser Computer hat ein Problem, Grafiken anzuzeigen: [problem]."
# renpy/common/00gltest.rpy:128
old "Its graphics drivers may be out of date or not operating correctly. This can lead to slow or incorrect graphics display. Updating DirectX could fix this problem."
new "Die Grafiktreiber könnten nicht mehr aktuell sein oder nicht korrekt funktionieren. Dies kann zu langsamer oder inkorrekter Grafikanzeige führen. Das Aktualisieren von DirectX könnte dieses Problem beheben."
# renpy/common/00gltest.rpy:130
old "Its graphics drivers may be out of date or not operating correctly. This can lead to slow or incorrect graphics display."
new "Die Grafiktreiber könnten nicht mehr aktuell sein oder nicht korrekt funktionieren. Dies kann zu langsamer oder inkorrekter Grafikanzeige führen."
# renpy/common/00gltest.rpy:135
old "Update DirectX"
new "DirectX aktualisieren"
# renpy/common/00gltest.rpy:141
old "Continue, Show this warning again"
new "Fortsetzen, diese Warnung wieder anzeigen"
# renpy/common/00gltest.rpy:145
old "Continue, Don't show warning again"
new "Fortsetzen, diese Warnung nicht mehr anzeigen"
# renpy/common/00gltest.rpy:171
old "Updating DirectX."
new "DirectX aktualisieren."
# renpy/common/00gltest.rpy:175
old "DirectX web setup has been started. It may start minimized in the taskbar. Please follow the prompts to install DirectX."
new "DirectX Websetup wurde gestartet. Es könnte minimiert in der Taskleiste starten. Bitte folgen Sie den Anweisungen, um DirectX zu installieren."
# renpy/common/00gltest.rpy:179
old "{b}Note:{/b} Microsoft's DirectX web setup program will, by default, install the Bing toolbar. If you do not want this toolbar, uncheck the appropriate box."
new "{b}Anmerkung:{/b} Microsofts DirectX Websetup-Programm installiert automatisch die Bing-Toolbar. Wenn Sie diese Toolbar nicht möchten, entfernen Sie das Häkchen bei der entsprechenden Schaltfläche."
# renpy/common/00gltest.rpy:183
old "When setup finishes, please click below to restart this program."
new "Wenn die Installation abgeschlossen ist, klicken Sie bitte unten, um dieses Programm neuzustarten."
# renpy/common/00gltest.rpy:185
old "Restart"
new "Neustart"
translate german strings:
# renpy/common/00keymap.rpy:167
old "Saved screenshot as %s."
new "Screenshot unter %s gespeichert."
translate german strings:
# renpy/common/00layout.rpy:421
old "Are you sure?"
new "Sind Sie sicher?"
# renpy/common/00layout.rpy:422
old "Are you sure you want to delete this save?"
new "Sind Sie sicher, dass Sie diese Datei löschen möchten?"
# renpy/common/00layout.rpy:423
old "Are you sure you want to overwrite your save?"
new "Sind Sie sicher, dass Sie diese Datei überschreiben möchten?"
# renpy/common/00layout.rpy:424
old "Loading will lose unsaved progress.\nAre you sure you want to do this?"
new "Beim Laden geht ungespeicherter Fortschritt verloren.\nSind Sie sicher, dass Sie das tun möchten?"
# renpy/common/00layout.rpy:425
old "Are you sure you want to quit?"
new "Sind Sie sicher, dass Sie beenden möchten?"
# renpy/common/00layout.rpy:426
old "Are you sure you want to return to the main menu?\nThis will lose unsaved progress."
new "Sind Sie sicher, dass Sie zurück zum Hauptmenü möchten?\nUngespeicherter Fortschritt geht dabei verloren."
# renpy/common/00layout.rpy:427
old "Are you sure you want to begin skipping?"
new "Sind Sie sicher, dass Sie vorspulen möchten?"
# renpy/common/00layout.rpy:428
old "Are you sure you want to skip to the next choice?"
new "Sind Sie sicher, dass Sie zur nächsten Auswahl vorspulen möchten?"
# renpy/common/00layout.rpy:429
old "Are you sure you want to skip to unseen dialogue or the next choice?"
new "Sind Sie sicher, dass Sie zum nächsten ungelesenen Dialog oder zur nächsten Auswahl vorspulen möchten?"
translate german strings:
# renpy/common/00library.rpy:77
old "Skip Mode"
new "Vorspulen"
# renpy/common/00library.rpy:80
old "Fast Skip Mode"
new "Schnell vorspulen"
translate german strings:
# renpy/common/00updater.rpy:1255
old "Updater"
new "Aktualisieren"
# renpy/common/00updater.rpy:1264
old "This program is up to date."
new "Dieses Programm ist aktuell."
# renpy/common/00updater.rpy:1266
old "[u.version] is available. Do you want to install it?"
new "[u.version] ist verfügbar. Möchten Sie sie installieren?"
# renpy/common/00updater.rpy:1268
old "Preparing to download the updates."
new "Vorbereiten, um die Aktualisierungen herunterzuladen."
# renpy/common/00updater.rpy:1270
old "Downloading the updates."
new "Aktualisierungen werden heruntergeladen."
# renpy/common/00updater.rpy:1272
old "Unpacking the updates."
new "Aktualisierungen werden entpackt."
# renpy/common/00updater.rpy:1276
old "The updates have been installed. The program will restart."
new "Die Aktualisierungen wurden installiert. Das Programm wird nun neustarten."
# renpy/common/00updater.rpy:1278
old "The updates have been installed."
new "Die Aktualisierungen wurden installiert."
# renpy/common/00updater.rpy:1280
old "The updates were cancelled."
new "Die Aktualisierungen wurden abgebrochen."
translate german strings:
# renpy/common/_compat/gamemenu.rpym:180
old "Empty Slot."
new "Leerer Speicherplatz."
# renpy/common/_compat/gamemenu.rpym:337
old "Previous"
new "Vorige"
# renpy/common/_compat/gamemenu.rpym:344
old "Next"
new "Nächste"
translate german strings:
# renpy/common/_compat/preferences.rpym:411
old "Joystick Mapping"
new "Joystickbelegung"
translate german strings:
# renpy/common/_errorhandling.rpym:434
old "Rollback"
new "Zurückscrollen"
# renpy/common/_errorhandling.rpym:436
old "Attempts a roll back to a prior time, allowing you to save or choose a different choice."
new "Versucht zu einem früheren Zeitpunkt zu gehen und ermöglicht es zu speichern oder eine andere Auswahl zu treffen."
# renpy/common/_errorhandling.rpym:441
old "Ignores the exception, allowing you to continue. This often leads to additional errors."
new "Ignoriert den Fehler und ermöglicht es, fortzufahren. Dies führt oft zu weiteren Fehlern."
# renpy/common/_errorhandling.rpym:446
old "Reloads the game from disk, saving and restoring game state if possible."
new "Startet das Spiel neu und stellt den Spielstand wieder her, wenn möglich."
# renpy/common/_errorhandling.rpym:450
old "Opens the traceback.txt file in a text editor."
new "Öffnet die traceback.txt Datei in einem Texteditor."
# renpy/common/_errorhandling.rpym:483
old "Parsing the script failed."
new "Syntaxanalyse gescheitert."
# renpy/common/_errorhandling.rpym:510
old "Open Parse Errors"
new "Fehleranalyse öffnen"
# renpy/common/_errorhandling.rpym:512
old "Opens the errors.txt file in a text editor."
new "Öffnet die errors.txt Datei in einem Texteditor."
translate german strings:
# renpy/common/_layout/classic_load_save.rpym:152
old "a"
new "a"
# renpy/common/_layout/classic_load_save.rpym:161
old "q"
new "s"
translate german strings:
# renpy/common/00console.rpy:179
old "%(version)s console, originally by Shiz, C, and delta.\n"
new "%(version)s Konsole, ursprünglich von Shiz, C und delta.\n"
# renpy/common/00console.rpy:180
old "Press <esc> to exit console. Type help for help.\n"
new "Drücken Sie <esc>, um die Konsole zu schließen. Geben Sie „help“ ein, um die Hilfe anzuzeigen.\n"
# renpy/common/00console.rpy:184
old "Ren'Py script enabled."
new "Ren’Py Skript aktiviert."
# renpy/common/00console.rpy:186
old "Ren'Py script disabled."
new "Ren’Py Skript deaktiviert."
# renpy/common/00console.rpy:392
old "help: show this help"
new "help: zeigt diese Hilfe an"
# renpy/common/00console.rpy:397
old "commands:\n"
new "Befehle:\n"
# renpy/common/00console.rpy:407
old " <renpy script statement>: run the statement\n"
new " <renpy script statement>: startet die Anweisung\n"
# renpy/common/00console.rpy:409
old " <python expression or statement>: run the expression or statement"
new " <python expression or statement>: startet den Ausdruck oder die Anweisung"
# renpy/common/00console.rpy:417
old "clear: clear the console history"
new "clear: leert das Konsolenprotokoll"
# renpy/common/00console.rpy:421
old "exit: exit the console"
new "exit: schließt die Konsole"
# renpy/common/00console.rpy:429
old "load <slot>: loads the game from slot"
new "load <slot>: lädt das Spiel aus dem Speicherplatz"
# renpy/common/00console.rpy:442
old "save <slot>: saves the game in slot"
new "save <slot>: speichert das Spiel im Speicherplatz"
# renpy/common/00console.rpy:453
old "reload: reloads the game, refreshing the scripts"
new "reload: startet das Spiel neu und erneuert die Skripte"
# renpy/common/00console.rpy:461
old "watch <expression>: watch a python expression"
new "watch <expression>: beobachtet einen Python-Ausdruck"
# renpy/common/00console.rpy:470
old "unwatch <expression>: stop watching an expression"
new "unwatch <expression>: beendet das Beobachten eines Ausdrucks"
# renpy/common/00console.rpy:478
old "unwatchall: stop watching all expressions"
new "unwatchall: beendet das Beobachten aller Ausdrücke"
# renpy/common/00console.rpy:484
old "jump <label>: jumps to label"
new "jump <label>: springt zum Label"
translate german strings:
# renpy/common/00keymap.rpy:332
old "Autoreload"
new "Autoneustart"
translate german strings:
# renpy/common/_developer/developer.rpym:65
old "Developer Menu"
new "Entwicklermenü"
# renpy/common/_developer/developer.rpym:67
old "Reload Game (Shift+R)"
new "Spiel neustarten (Shift + R)"
# renpy/common/_developer/developer.rpym:69
old "Console (Shift+O)"
new "Konsole (Shift + O)"
# renpy/common/_developer/developer.rpym:71
old "Variable Viewer"
new "Variablen anzeigen"
# renpy/common/_developer/developer.rpym:73
old "Theme Test"
new "Themetest"
# renpy/common/_developer/developer.rpym:75
old "Image Location Picker"
new "Grafikposition auswählen"
# renpy/common/_developer/developer.rpym:77
old "Filename List"
new "Liste der Dateinamen"
# renpy/common/_developer/developer.rpym:81
old "Show Image Load Log"
new "Grafiklog anzeigen"
# renpy/common/_developer/developer.rpym:84
old "Hide Image Load Log"
new "Grafiklog verbergen"
# renpy/common/_developer/developer.rpym:149
old "No variables have changed since the game started."
new "Keine Variablen wurden geändert, seit das Spiel gestartet wurde."
# renpy/common/_developer/developer.rpym:152
old "Return to the developer menu"
new "Zurück zum Entwicklermenü"
# renpy/common/_developer/developer.rpym:272
old "{b}Missing Images{/b}"
new "{b}Fehlende Grafiken{/b}"
# renpy/common/_developer/developer.rpym:424
old "Rectangle: %r"
new "Rechteck: %r"
# renpy/common/_developer/developer.rpym:429
old "Mouse position: %r"
new "Mausposition: %r"
# renpy/common/_developer/developer.rpym:431
old "Right-click or escape to quit."
new "Rechtsklick oder Escape, um zu beenden."
# renpy/common/_developer/developer.rpym:482
old "Done"
new "Fertig"
translate german strings:
# renpy/common/_developer/inspector.rpym:43
old "Displayable Inspector"
new "Darstellungen prüfen"
# renpy/common/_developer/inspector.rpym:49
old "Nothing to inspect."
new "Nichts zum Prüfen verfügbar"
# renpy/common/_developer/inspector.rpym:58
old "Size"
new "Größe"
# renpy/common/_developer/inspector.rpym:63
old "Style"
new "Stil"
# renpy/common/_developer/inspector.rpym:123
old "Inspecting Styles of [displayable_name!q]"
new "Prüft Stile von [displayable_name!q]"
# renpy/common/_developer/inspector.rpym:135
old "displayable:"
new "Darstellungen:"
# renpy/common/_developer/inspector.rpym:142
old " (no properties affect the displayable)"
new " (keine Eigenschaften beeinflussen diese Darstellung)"
new "Das [variant] [format] Package wird erstellt."
# game/distribute.rpy:735
old "Making the [variant] update zsync file."
new "Die [variant] Update-zsync-Datei wird erstellt."
# game/distribute.rpy:831
old "Processed {b}[complete]{/b} of {b}[total]{/b} files."
new "{b}[complete]{/b} von {b}[total]{/b} Dateien verarbeitet."
# game/distribute.rpy:892
old "All packages have been built.\n\nDue to the presence of permission information, unpacking and repacking the Linux and Macintosh distributions on Windows is not supported."
new "Alle Packages wurden erstellt.\n\nAufgrund von Zugriffsinformationen ist das Entpacken und Neupacken der Linux und Macintosh Veröffentlichungen unter Windows nicht unterstützt."
# game/distribute.rpy:358
old "No packages are selected, so there's nothing to do."
new "Keine Packages wurden ausgewählt."
# game/distribute.rpy:335
old "Building distributions failed:\n\nThe build.directory_name variable may not include the space, colon, or semicolon characters."
new "Erstellen von Veröffentlichungen gescheiter:\n\nDie build.directory_name Variable darf keine Leerzeichen, Doppelpunkte oder Semikolons enthalten."
old "Build Distributions: [project.current.name!q]"
new "Erstellt Veröffentlichung: [project.current.name!q]"
# game/distribute_gui.rpy:154
old "Directory Name:"
new "Verzeichnisname:"
# game/distribute_gui.rpy:158
old "Executable Name:"
new "Programmdateiname:"
# game/distribute_gui.rpy:167
old "Actions:"
new "Aktionen:"
# game/distribute_gui.rpy:175
old "Edit options.rpy"
new "options.rpy bearbeiten"
# game/distribute_gui.rpy:176
old "Refresh"
new "Aktualisieren"
# game/distribute_gui.rpy:193
old "Build Packages:"
new "Packages erstellen:"
# game/distribute_gui.rpy:208
old "Build Updates"
new "Aktualisierungen erstellen"
# game/distribute_gui.rpy:212
old "Build"
new "Erstellen"
# game/distribute_gui.rpy:219
old "Errors were detected when running the project. Please ensure the project runs without errors before building distributions."
new "Fehler wurden beim Starten des Projekts gefunden. Bitte stellen Sie sicher, dass das Projekt ohne Fehler läuft, bevor Sie Veröffentlichungen erstellen."
# game/distribute_gui.rpy:236
old "Your project does not contain build information. Would you like to add build information to the end of options.rpy?"
new "Ihr Projekt enthält keine Erstellinformationen. Würden Sie gerne Erstellinformationen am Ende der options.rpy-Datei einfügen?"
old "{b}Recommended.{/b} A beta editor with an easy to use interface and features that aid in development, such as spell-checking. Editra currently lacks the IME support required for Chinese, Japanese, and Korean text input."
new "{b}Empfohlen.{/b} Ein Betaeditor mit einer leichten Benutzeroberfläche und Funktionen, die bei der Entwicklung helfen, wie eine Rechtschreibprüfung. Editra fehlt derzeit die Eingabemethode, die für Chinesisch, Japanisch und Koreanisch benötigt wird."
# game/editor.rpy:121
old "{b}Recommended.{/b} A beta editor with an easy to use interface and features that aid in development, such as spell-checking. Editra currently lacks the IME support required for Chinese, Japanese, and Korean text input. On Linux, Editra requires wxPython."
new "{b}Empfohlen.{/b} Ein Betaeditor mit einer leichten Benutzeroberfläche und Funktionen, die bei der Entwicklung helfen, wie eine Rechtschreibprüfung. Editra fehlt derzeit die Eingabemethode, die für Chinesisch, Japanisch und Koreanisch benötigt wird. Unter Linux benötigt Editra wxPython."
# game/editor.rpy:137
old "This may have occured because wxPython is not installed on this system."
new "Dies ist vermutlich passiert, weil wxPython nicht auf Ihrem System installiert ist."
# game/editor.rpy:144
old "Up to 22 MB download required."
new "Etwa 22 MB benötigt."
# game/editor.rpy:157
old "1.8 MB download required."
new "1,8 MB benötigt."
# game/editor.rpy:158
old "This may have occured because Java is not installed on this system."
new "Dies ist vermutlich passiert, weil Java nicht auf Ihrem System installiert ist."
# game/editor.rpy:327
old "An exception occured while launching the text editor:\n[exception!q]"
new "Ein Fehler ist beim Starten des Texteditors aufgetreten:\n[exception!q]"
# game/editor.rpy:378
old "Select Editor"
new "Editor auswählen"
# game/editor.rpy:393
old "A text editor is the program you'll use to edit Ren'Py script files. Here, you can select the editor Ren'Py will use. If not already present, the editor will be automatically downloaded and installed."
new "Ein Texeditor ist ein Programm, das verwendet wird, um Ren’Py Skript-Dateien zu bearbeiten. Hier können Sie den Editor auswählen, den Ren’Py verwenden soll. Wenn dieser noch nicht installiert ist, wird er automatisch heruntergeladen und installiert."
# game/editor.rpy:415
old "Cancel"
new "Abbrechen"
old "A mature editor that requires Java."
new "Ein fortgeschrittener Editor, der Java benötigt."
old "System Editor"
new "Systemeditor"
old "Invokes the editor your operating system has associated with .rpy files."
new "Startet den Editor, den dein Betriebssystem mit .rpy-Dateien assoziiert."
old "None"
new "Keinen"
old "Prevents Ren'Py from opening a text editor."
new "Verhindert, dass Ren’Py einen Texteditor öffnet."
Some files were not shown because too many files have changed in this diff
Show More
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
Tom Rothamel
Civa Lin
tlm-2501
Daniel Luque
Renoa
javimat
kyouryuukunn
Matias Giachino
Koichi Akabe
Nobody Really
Helloise
Shiz
huanxuantian
duanemoody
antoinentx
M v H
Tom Rothamel
morio
DragoonHP
paulmorio
James Pearson
kyouryuukunn
Christian Koepp
JaHIY
xRenx
Albert Westra
apricotorange
Edwin
JakeStaines
SleepKirby
